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


#define SWIG_VERSION 0x040301
#define SWIGPYTHON
#define SWIG_DIRECTORS
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE

#define SWIG_name    "_fltk"
/* -----------------------------------------------------------------------------
 *  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__)
#   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_NULLPTR nullptr
#else
# define SWIG_NULLPTR NULL
#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 defined(SWIGPYTHON_BUILTIN) && defined(SWIG_HEAPTYPES)
/* SWIG_HEAPTYPES is not ready for use with SWIGPYTHON_BUILTIN, but if turned on manually requires the following */
#if PY_VERSION_HEX >= 0x03030000 && PY_VERSION_HEX < 0x030c0000
#include <structmember.h>
#define Py_READONLY READONLY
#define Py_T_PYSSIZET T_PYSSIZET
#endif
#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 "4"

/* 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 cast in linked list */
  struct swig_cast_info  *prev;			/* pointer to the previous cast */
} 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;
}

/*
  Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (strcmp(iter->type->name, c) == 0) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (iter->type == from) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->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 *cast = ti->cast;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;

  while (cast) {
    if (!cast->converter) {
      swig_type_info *tc = cast->type;
      if (!tc->clientdata) {
	SWIG_TypeClientData(tc, clientdata);
      }
    }
    cast = cast->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


/* 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


/* 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
}

/* 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_data" SWIG_RUNTIME_VERSION "." 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

#ifdef 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

/* -----------------------------------------------------------------------------
 * 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 < 0x03030000
# error "This version of SWIG only supports Python 3 >= 3.3"
#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

/* 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 *
swig_varlink_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 *
swig_varlink_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
swig_varlink_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 *
swig_varlink_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
swig_varlink_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;
}

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

SWIGINTERN PyTypeObject*
swig_varlink_type(void) {
  static char varlink__doc__[] = "Swig var 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
      "swigvarlink",                      /* tp_name */
      sizeof(swig_varlinkobject),         /* tp_basicsize */
      0,                                  /* tp_itemsize */
      (destructor) swig_varlink_dealloc,  /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                       /* tp_print */
#else
      (Py_ssize_t)0,                      /* tp_vectorcall_offset */
#endif
      (getattrfunc) swig_varlink_getattr, /* tp_getattr */
      (setattrfunc) swig_varlink_setattr, /* tp_setattr */
      0,                                  /* tp_compare */
      (reprfunc) swig_varlink_repr,       /* tp_repr */
      0,                                  /* tp_as_number */
      0,                                  /* tp_as_sequence */
      0,                                  /* tp_as_mapping */
      0,                                  /* tp_hash */
      0,                                  /* tp_call */
      (reprfunc) swig_varlink_str,        /* tp_str */
      0,                                  /* tp_getattro */
      0,                                  /* tp_setattro */
      0,                                  /* tp_as_buffer */
      0,                                  /* tp_flags */
      varlink__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
    };
    varlink_type = tmp;
    type_init = 1;
    if (PyType_Ready(&varlink_type) < 0)
      return NULL;
  }
  return &varlink_type;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)swig_varlink_dealloc },
    { Py_tp_repr, (void *)swig_varlink_repr },
    { Py_tp_getattr, (void *)swig_varlink_getattr },
    { Py_tp_setattr, (void *)swig_varlink_setattr },
    { Py_tp_str, (void *)swig_varlink_str },
    { Py_tp_doc, (void *)varlink__doc__ },
    { 0, NULL }
  };
  PyType_Spec spec = {
    "swigvarlink",
    sizeof(swig_varlinkobject),
    0,
    Py_TPFLAGS_DEFAULT,
    slots
  };
  return (PyTypeObject *)PyType_FromSpec(&spec);
#endif
}

/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
  swig_varlinkobject *result = PyObject_New(swig_varlinkobject, swig_varlink_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;
#ifdef SWIGPYTHON_BUILTIN
  PyObject *dict;
#endif
} SwigPyObject;


#ifdef SWIGPYTHON_BUILTIN

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

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

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

#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 swigobject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  return SwigPyObject_repr((SwigPyObject*)v);
}

SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
  void *i = v->ptr;
  void *j = w->ptr;
  return (i < j) ? -1 : ((i > j) ? 1 : 0);
}

/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
  PyObject* res = NULL;
  if (!PyErr_Occurred()) {
    if (op != Py_EQ && op != Py_NE) {
      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
  if (PyType_IsSubtype(op_type, target_tp))
    return 1;
  return (strcmp(op_type->tp_name, "SwigPyObject") == 0);
#else
# ifdef Py_LIMITED_API
  int cmp;
  PyObject *tp_name;
#endif
  if (op_type == target_tp)
    return 1;
# ifdef Py_LIMITED_API
  tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
  if (!tp_name)
    return 0;
  cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyObject");
  SWIG_Py_DECREF(tp_name);
  return cmp == 0;
# else
  return (strcmp(op_type->tp_name, "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);
#ifdef SWIGPYTHON_BUILTIN
  SWIG_Py_XDECREF(sobj->dict);
#endif
  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
swigobject_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 swigobject_doc[] = "Swig object carries a C/C++ instance 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
      "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 */
      swigobject_doc,                       /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      swigobject_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
    };
    swigpyobject_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpyobject_type) != 0)
      return NULL;
  }
  return &swigpyobject_type;
#else
  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 *)swigobject_doc },
    { Py_tp_richcompare, (void *)SwigPyObject_richcompare },
    { Py_tp_methods, (void *)swigobject_methods },
    { Py_nb_int, (void *)SwigPyObject_long },
    { 0, NULL }
  };
  PyType_Spec spec = {
    "SwigPyObject",
    sizeof(SwigPyObject),
    0,
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
    slots
  };
  return (PyTypeObject *)PyType_FromSpec(&spec);
#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;
#ifdef SWIGPYTHON_BUILTIN
    sobj->dict = 0;
#endif
    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) {
#ifdef Py_LIMITED_API
  int cmp;
  PyObject *tp_name;
#endif
  PyTypeObject* op_type = Py_TYPE(op);
  if (op_type == SwigPyPacked_TypeOnce())
    return 1;
#ifdef Py_LIMITED_API
  tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
  if (!tp_name)
    return 0;
  cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyPacked");
  SWIG_Py_DECREF(tp_name);
  return cmp == 0;
#else
  return (strcmp(op_type->tp_name, "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 swigpacked_doc[] = "Swig object carries a C/C++ instance 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
      "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 */
      swigpacked_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
    };
    swigpypacked_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpypacked_type) != 0)
      return NULL;
  }
  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 *)swigpacked_doc },
    { 0, NULL }
  };
  PyType_Spec spec = {
    "SwigPyPacked",
    sizeof(SwigPyPacked),
    0,
    Py_TPFLAGS_DEFAULT,
    slots
  };
  return (PyTypeObject *)PyType_FromSpec(&spec);
#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

SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj) 
{
  PyObject *obj;

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

#ifdef SWIGPYTHON_BUILTIN
  (void)obj;
# ifdef PyWeakref_CheckProxy
  if (PyWeakref_CheckProxy(pyobj)) {
#if PY_VERSION_HEX >= 0x030d0000
    PyWeakref_GetRef(pyobj, &pyobj);
    Py_DECREF(pyobj);
#else
    pyobj = PyWeakref_GET_OBJECT(pyobj);
#endif
    if (pyobj && SwigPyObject_Check(pyobj))
      return (SwigPyObject*) pyobj;
  }
# endif
  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 {
#ifdef PyWeakref_CheckProxy
      if (PyWeakref_CheckProxy(pyobj)) {
	PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
      }
#endif
      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;
#ifdef SWIGPYTHON_BUILTIN
        newobj->dict = 0;
#endif
      }
    } else {
      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
#ifdef SWIGPYTHON_BUILTIN
      if (newobj) {
        newobj->dict = 0;
      }
#endif
    }
    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;
}


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_Py_DECREF(SWIG_This());
  Swig_This_global = NULL;
  SWIG_Py_DECREF(SWIG_globals());
  Swig_Globals_global = NULL;
  SWIG_Py_DECREF(SWIG_Python_TypeCache());
  Swig_TypeCache_global = NULL;
  Swig_Capsule_global = NULL;
}

SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
 /* Add a dummy module object into sys.modules */
  PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
  PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
  if (pointer && module) {
    if (PyModule_AddObject(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)
{
  PyObject *cache = SWIG_Python_TypeCache();
  PyObject *key = SWIG_Python_str_FromChar(type); 
  PyObject *obj = PyDict_GetItem(cache, key);
  swig_type_info *descriptor;
  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_SetItem(cache, key, obj);
        SWIG_Py_DECREF(obj);
      }
    }
  }
  SWIG_Py_DECREF(key);
  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 : "";
}

SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
  (void) obj;
  if (type) {
#if defined(SWIG_COBJECT_TYPES)
    if (obj && SwigPyObject_Check(obj)) {
      const char *otype = (const char *) SwigPyObject_GetDesc(obj);
      if (otype) {
	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
		     type, otype);
	return;
      }
    } else 
#endif      
    {
#ifndef Py_LIMITED_API
      /* tp_name is not accessible */
      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
      if (otype) {
	PyObject *str = PyObject_Str(obj);
	PyObject *bytes = NULL;
	const char *cstr = str ? SWIG_PyUnicode_AsUTF8AndSize(str, NULL, &bytes) : 0;
	if (cstr) {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
		       type, otype, cstr);
	} else {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
		       type, otype);
	}
	SWIG_Py_XDECREF(bytes);
	SWIG_Py_XDECREF(str);
	return;
      }
#endif
    }   
    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
  } else {
    PyErr_Format(PyExc_TypeError, "unexpected type is received");
  }
}


/* 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 = obj->ob_type;
  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
  {
    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
    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 = descr->ob_type->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;
    }
    PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
    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) 


/* -----------------------------------------------------------------------------
 * director_common.swg
 *
 * This file contains support for director classes which is common between
 * languages.
 * ----------------------------------------------------------------------------- */

/*
  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
  'Swig' namespace. This could be useful for multi-modules projects.
*/
#ifdef SWIG_DIRECTOR_STATIC
/* Force anonymous (static) namespace */
#define Swig
#endif
/* -----------------------------------------------------------------------------
 * director_py_mutex.swg
 *
 * contains python mutex for threads
 * ----------------------------------------------------------------------------- */

#if defined(SWIG_PYTHON_THREADS) && !defined(SWIG_THREADS)
#define SWIG_THREADS 1
#endif
#if defined(SWIG_THREADS) && !defined(Py_LIMITED_API)
#include "pythread.h"
#define SWIG_HAVE_MUTEX
namespace Swig {
   class Mutex
   {
       PyThread_type_lock mutex_;
   public:
       Mutex() : mutex_(PyThread_allocate_lock()) {}
       ~Mutex() { PyThread_free_lock(mutex_); }
       void lock() { PyThread_acquire_lock(mutex_, WAIT_LOCK); }
       void unlock() { PyThread_release_lock(mutex_); }
   };
}
#endif
/* -----------------------------------------------------------------------------
 * director_guard.swg
 *
 * Generic Mutex implementation for directors
 *
 * Before including this file, there are two macros to define for choosing
 * an implementation as follows:
 * - SWIG_THREADS:
 *   If defined than mutexes are used.
 *   If not defined then mutexes are not used.
 * - SWIG_HAVE_MUTEX:
 *   If there is a target language defined 'Mutex' class available, the target
 *     language will define this macro to use the class over the options below.
 *     The language 'Mutex' class needs to be Basic Lockable.
 *     It must have public 'void lock()' and 'void unlock()' methods.
 *     See: https://en.cppreference.com/w/cpp/named_req/BasicLockable
 *   If the macro is not defined, one of the following will be used in this order:
 *   - std::mutex if using C++11 or later.
 *   - CRITICAL_SECTION on Windows.
 *   - POSIX pthread mutex.
 * ----------------------------------------------------------------------------- */

#ifdef SWIG_THREADS

#if __cplusplus >= 201103L
/*
 * C++ 11 or above
 * std::mutex        https://en.cppreference.com/w/cpp/thread/mutex
 * std::unique_lock  https://en.cppreference.com/w/cpp/thread/unique_lock
 */
#include <mutex>
#ifdef SWIG_HAVE_MUTEX
/* Use Language defined Mutex class */
#define SWIG_GUARD(_mutex) std::unique_lock<Mutex> _guard(_mutex)
#define SWIG_GUARD_DEFINITION(_cls, _mutex) Mutex _cls::_mutex
#define SWIG_GUARD_DECLARATION(_mutex) static Mutex _mutex
#else
#define SWIG_GUARD(_mutex) std::unique_lock<std::mutex> _guard(_mutex)
#define SWIG_GUARD_DEFINITION(_cls, _mutex) std::mutex _cls::_mutex
#define SWIG_GUARD_DECLARATION(_mutex) static std::mutex _mutex
#endif

#else /* __cplusplus */

#ifdef SWIG_HAVE_MUTEX
/* Use Language defined Mutex class */

#elif defined(_WIN32)
/*
 * Windows Critical Section Objects
 * https://learn.microsoft.com/en-us/windows/win32/Sync/critical-section-objects
 */
#include <windows.h>
#include <synchapi.h>
namespace Swig {
    class Mutex {
        CRITICAL_SECTION mutex_;
    public:
        Mutex() { InitializeCriticalSection(&mutex_); }
        ~Mutex() { DeleteCriticalSection(&mutex_); }
        void lock() { EnterCriticalSection(&mutex_); }
        void unlock() { LeaveCriticalSection(&mutex_); }
    };
}

#else /* _WIN32 */
/*
 * POSIX Thread mutex
 * https://pubs.opengroup.org/onlinepubs/7908799/xsh/pthread.h.html
 */
#include <pthread.h>
namespace Swig {
    class Mutex {
        pthread_mutex_t mutex_;
    public:
        Mutex() { pthread_mutex_init(&mutex_, NULL); }
        ~Mutex() { pthread_mutex_destroy(&mutex_); }
        void lock() { pthread_mutex_lock(&mutex_); }
        void unlock() { pthread_mutex_unlock(&mutex_); }
    };
}

#endif /* _WIN32 */

namespace Swig {
    class Unique_lock {
        Mutex &mutex_;
    public:
        Unique_lock(Mutex &_mutex) : mutex_(_mutex) { mutex_.lock(); }
        ~Unique_lock() { mutex_.unlock(); }
    };
}
#define SWIG_GUARD(_mutex) Unique_lock _guard(_mutex)
#define SWIG_GUARD_DEFINITION(_cls, _mutex) Mutex _cls::_mutex
#define SWIG_GUARD_DECLARATION(_mutex) static Mutex _mutex

#endif /* __cplusplus */

#else /* SWIG_THREADS */

#define SWIG_GUARD(_mutex)
#define SWIG_GUARD_DEFINITION(_cls, _mutex)
#define SWIG_GUARD_DECLARATION(_mutex)

#endif /* SWIG_THREADS */
/* -----------------------------------------------------------------------------
 * director.swg
 *
 * This file contains support for director classes so that Python proxy
 * methods can be called from C++.
 * ----------------------------------------------------------------------------- */

#ifndef SWIG_DIRECTOR_PYTHON_HEADER_
#define SWIG_DIRECTOR_PYTHON_HEADER_

#include <string>
#include <iostream>
#include <exception>
#include <vector>
#include <map>

/*
  Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual
  table', and avoid multiple GetAttr calls to retrieve the python
  methods.
*/

#ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE
#ifndef SWIG_PYTHON_DIRECTOR_VTABLE
#define SWIG_PYTHON_DIRECTOR_VTABLE
#endif
#endif



/*
  Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the
  Undefined Exception Handler provided by swig.
*/
#ifndef SWIG_DIRECTOR_NO_UEH
#ifndef SWIG_DIRECTOR_UEH
#define SWIG_DIRECTOR_UEH
#endif
#endif


/*
  Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the
  native C++ RTTI and dynamic_cast<>. But be aware that directors
  could stop working when using this option.
*/
#ifdef SWIG_DIRECTOR_NORTTI
/*
   When we don't use the native C++ RTTI, we implement a minimal one
   only for Directors.
*/
# ifndef SWIG_DIRECTOR_RTDIR
# define SWIG_DIRECTOR_RTDIR

namespace Swig {
  class Director;
  SWIGINTERN std::map<void *, Director *>& get_rtdir_map() {
    static std::map<void *, Director *> rtdir_map;
    return rtdir_map;
  }

  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) {
    get_rtdir_map()[vptr] = rtdir;
  }

  SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
    std::map<void *, Director *>::const_iterator pos = get_rtdir_map().find(vptr);
    Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0;
    return rtdir;
  }
}
# endif /* SWIG_DIRECTOR_RTDIR */

# define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast<void *>(ARG))
# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast<void *>(ARG1), ARG2)

#else

# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
# define SWIG_DIRECTOR_RGTR(ARG1, ARG2)

#endif /* SWIG_DIRECTOR_NORTTI */

extern "C" {
  struct swig_type_info;
}

namespace Swig {

  /* memory handler */
  struct GCItem {
    virtual ~GCItem() {}

    virtual int get_own() const {
      return 0;
    }
  };

  struct GCItem_var {
    GCItem_var(GCItem *item = 0) : _item(item) {
    }

    GCItem_var& operator=(GCItem *item) {
      GCItem *tmp = _item;
      _item = item;
      delete tmp;
      return *this;
    }

    ~GCItem_var() {
      delete _item;
    }

    GCItem * operator->() const {
      return _item;
    }

  private:
    GCItem *_item;
  };

  struct GCItem_Object : GCItem {
    GCItem_Object(int own) : _own(own) {
    }

    virtual ~GCItem_Object() {
    }

    int get_own() const {
      return _own;
    }

  private:
    int _own;
  };

  template <typename Type>
  struct GCItem_T : GCItem {
    GCItem_T(Type *ptr) : _ptr(ptr) {
    }

    virtual ~GCItem_T() {
      delete _ptr;
    }

  private:
    Type *_ptr;
  };

  template <typename Type>
  struct GCArray_T : GCItem {
    GCArray_T(Type *ptr) : _ptr(ptr) {
    }

    virtual ~GCArray_T() {
      delete[] _ptr;
    }

  private:
    Type *_ptr;
  };

  /* base class for director exceptions */
  class DirectorException : public std::exception {
  protected:
    std::string swig_msg;
  public:
    DirectorException(PyObject *error, const char *hdr ="", const char *msg ="") : swig_msg(hdr) {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (msg[0]) {
        swig_msg += " ";
        swig_msg += msg;
      }
      if (!PyErr_Occurred()) {
        PyErr_SetString(error, swig_msg.c_str());
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
    }

    virtual ~DirectorException() throw() {
    }

    /* Deprecated, use what() instead */
    const char *getMessage() const {
      return what();
    }

    const char *what() const throw() {
      return swig_msg.c_str();
    }

    static void raise(PyObject *error, const char *msg) {
      throw DirectorException(error, msg);
    }

    static void raise(const char *msg) {
      raise(PyExc_RuntimeError, msg);
    }
  };

  /* type mismatch in the return value from a python method call */
  class DirectorTypeMismatchException : public DirectorException {
  public:
    DirectorTypeMismatchException(PyObject *error, const char *msg="")
      : DirectorException(error, "SWIG director type mismatch", msg) {
    }

    DirectorTypeMismatchException(const char *msg="")
      : DirectorException(PyExc_TypeError, "SWIG director type mismatch", msg) {
    }

    static void raise(PyObject *error, const char *msg) {
      throw DirectorTypeMismatchException(error, msg);
    }

    static void raise(const char *msg) {
      throw DirectorTypeMismatchException(msg);
    }
  };

  /* any python exception that occurs during a director method call */
  class DirectorMethodException : public DirectorException {
  public:
    DirectorMethodException(const char *msg = "")
      : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg) {
    }

    static void raise(const char *msg) {
      throw DirectorMethodException(msg);
    }
  };

  /* attempt to call a pure virtual method via a director method */
  class DirectorPureVirtualException : public DirectorException {
  public:
    DirectorPureVirtualException(const char *msg = "")
      : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg) {
    }

    static void raise(const char *msg) {
      throw DirectorPureVirtualException(msg);
    }
  };



  /* director base class */
  class Director {
  private:
    /* pointer to the wrapped python object */
    PyObject *swig_self;
    /* flag indicating whether the object is owned by python or c++ */
    mutable bool swig_disown_flag;

    /* decrement the reference count of the wrapped python object */
    void swig_decref() const {
      if (swig_disown_flag) {
        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
        SWIG_Py_DECREF(swig_self);
        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }

  public:
    /* wrap a python object. */
    Director(PyObject *self) : swig_self(self), swig_disown_flag(false) {
    }

    /* discard our reference at destruction */
    virtual ~Director() {
      swig_decref();
    }

    /* return a pointer to the wrapped python object */
    PyObject *swig_get_self() const {
      return swig_self;
    }

    /* acquire ownership of the wrapped python object (the sense of "disown" is from python) */
    void swig_disown() const {
      if (!swig_disown_flag) {
        swig_disown_flag=true;
        swig_incref();
      }
    }

    /* increase the reference count of the wrapped python object */
    void swig_incref() const {
      if (swig_disown_flag) {
        SWIG_Py_INCREF(swig_self);
      }
    }

    /* methods to implement pseudo protected director members */
    virtual bool swig_get_inner(const char * /* swig_protected_method_name */) const {
      return true;
    }

    virtual void swig_set_inner(const char * /* swig_protected_method_name */, bool /* swig_val */) const {
    }

  /* ownership management */
  private:
    typedef std::map<void *, GCItem_var> swig_ownership_map;
    mutable swig_ownership_map swig_owner;
    SWIG_GUARD_DECLARATION(swig_mutex_own);

  public:
    template <typename Type>
    void swig_acquire_ownership_array(Type *vptr) const {
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCArray_T<Type>(vptr);
      }
    }

    template <typename Type>
    void swig_acquire_ownership(Type *vptr) const {
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCItem_T<Type>(vptr);
      }
    }

    void swig_acquire_ownership_obj(void *vptr, int own) const {
      if (vptr && own) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCItem_Object(own);
      }
    }

    int swig_release_ownership(void *vptr) const {
      int own = 0;
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_ownership_map::iterator iter = swig_owner.find(vptr);
        if (iter != swig_owner.end()) {
          own = iter->second->get_own();
          swig_owner.erase(iter);
        }
      }
      return own;
    }

    template <typename Type>
    static PyObject *swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args)) {
      SwigPyObject *sobj = (SwigPyObject *)pyobj;
      sobj->own = 0;
      Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast<Type *>(sobj->ptr));
      if (d)
        d->swig_disown();
      return PyWeakref_NewProxy(pyobj, NULL);
    }
  };

  SWIG_GUARD_DEFINITION(Director, swig_mutex_own);
}

#endif

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

#define SWIGTYPE_p_FILE swig_types[0]
#define SWIGTYPE_p_FL_CHART_ENTRY swig_types[1]
#define SWIGTYPE_p_Fl_Abort_Handler swig_types[2]
#define SWIGTYPE_p_Fl_Adjuster swig_types[3]
#define SWIGTYPE_p_Fl_Anim_GIF_Image swig_types[4]
#define SWIGTYPE_p_Fl_Args_Handler swig_types[5]
#define SWIGTYPE_p_Fl_Atclose_Handler swig_types[6]
#define SWIGTYPE_p_Fl_Awake_Handler swig_types[7]
#define SWIGTYPE_p_Fl_BMP_Image swig_types[8]
#define SWIGTYPE_p_Fl_Bitmap swig_types[9]
#define SWIGTYPE_p_Fl_Box swig_types[10]
#define SWIGTYPE_p_Fl_Box_Draw_F swig_types[11]
#define SWIGTYPE_p_Fl_Box_Draw_Focus_F swig_types[12]
#define SWIGTYPE_p_Fl_Browser swig_types[13]
#define SWIGTYPE_p_Fl_Browser_ swig_types[14]
#define SWIGTYPE_p_Fl_Button swig_types[15]
#define SWIGTYPE_p_Fl_Callback_User_Data swig_types[16]
#define SWIGTYPE_p_Fl_Chart swig_types[17]
#define SWIGTYPE_p_Fl_Check_Browser swig_types[18]
#define SWIGTYPE_p_Fl_Check_Button swig_types[19]
#define SWIGTYPE_p_Fl_Choice swig_types[20]
#define SWIGTYPE_p_Fl_Clipboard_Notify_Handler swig_types[21]
#define SWIGTYPE_p_Fl_Clock swig_types[22]
#define SWIGTYPE_p_Fl_Clock_Output swig_types[23]
#define SWIGTYPE_p_Fl_Color_Chooser swig_types[24]
#define SWIGTYPE_p_Fl_Copy_Surface swig_types[25]
#define SWIGTYPE_p_Fl_Copy_Surface_Driver swig_types[26]
#define SWIGTYPE_p_Fl_Counter swig_types[27]
#define SWIGTYPE_p_Fl_Device_Plugin swig_types[28]
#define SWIGTYPE_p_Fl_Dial swig_types[29]
#define SWIGTYPE_p_Fl_Display_Device swig_types[30]
#define SWIGTYPE_p_Fl_Double_Window swig_types[31]
#define SWIGTYPE_p_Fl_EPS_File_Surface swig_types[32]
#define SWIGTYPE_p_Fl_End swig_types[33]
#define SWIGTYPE_p_Fl_File_Browser swig_types[34]
#define SWIGTYPE_p_Fl_File_Chooser swig_types[35]
#define SWIGTYPE_p_Fl_File_Icon swig_types[36]
#define SWIGTYPE_p_Fl_File_Input swig_types[37]
#define SWIGTYPE_p_Fl_Fill_Dial swig_types[38]
#define SWIGTYPE_p_Fl_Fill_Slider swig_types[39]
#define SWIGTYPE_p_Fl_Flex swig_types[40]
#define SWIGTYPE_p_Fl_Float_Input swig_types[41]
#define SWIGTYPE_p_Fl_GIF_Image swig_types[42]
#define SWIGTYPE_p_Fl_Gl_Window swig_types[43]
#define SWIGTYPE_p_Fl_Graphics_Driver swig_types[44]
#define SWIGTYPE_p_Fl_Grid swig_types[45]
#define SWIGTYPE_p_Fl_Grid__Cell swig_types[46]
#define SWIGTYPE_p_Fl_Group swig_types[47]
#define SWIGTYPE_p_Fl_Help_Dialog swig_types[48]
#define SWIGTYPE_p_Fl_Help_View swig_types[49]
#define SWIGTYPE_p_Fl_Hold_Browser swig_types[50]
#define SWIGTYPE_p_Fl_Hor_Fill_Slider swig_types[51]
#define SWIGTYPE_p_Fl_Hor_Nice_Slider swig_types[52]
#define SWIGTYPE_p_Fl_Hor_Slider swig_types[53]
#define SWIGTYPE_p_Fl_Hor_Value_Slider swig_types[54]
#define SWIGTYPE_p_Fl_ICO_Image swig_types[55]
#define SWIGTYPE_p_Fl_ICO_Image__IconDirEntry swig_types[56]
#define SWIGTYPE_p_Fl_Idle_Handler swig_types[57]
#define SWIGTYPE_p_Fl_Image swig_types[58]
#define SWIGTYPE_p_Fl_Image_Surface swig_types[59]
#define SWIGTYPE_p_Fl_Image_Surface_Driver swig_types[60]
#define SWIGTYPE_p_Fl_Input swig_types[61]
#define SWIGTYPE_p_Fl_Input_ swig_types[62]
#define SWIGTYPE_p_Fl_Input_Choice swig_types[63]
#define SWIGTYPE_p_Fl_Int_Input swig_types[64]
#define SWIGTYPE_p_Fl_JPEG_Image swig_types[65]
#define SWIGTYPE_p_Fl_Label swig_types[66]
#define SWIGTYPE_p_Fl_Label_Draw_F swig_types[67]
#define SWIGTYPE_p_Fl_Label_Measure_F swig_types[68]
#define SWIGTYPE_p_Fl_Light_Button swig_types[69]
#define SWIGTYPE_p_Fl_Line_Dial swig_types[70]
#define SWIGTYPE_p_Fl_Menu_ swig_types[71]
#define SWIGTYPE_p_Fl_Menu_Bar swig_types[72]
#define SWIGTYPE_p_Fl_Menu_Button swig_types[73]
#define SWIGTYPE_p_Fl_Menu_Item swig_types[74]
#define SWIGTYPE_p_Fl_Menu_Window swig_types[75]
#define SWIGTYPE_p_Fl_Multi_Browser swig_types[76]
#define SWIGTYPE_p_Fl_Multi_Label swig_types[77]
#define SWIGTYPE_p_Fl_Multiline_Input swig_types[78]
#define SWIGTYPE_p_Fl_Multiline_Output swig_types[79]
#define SWIGTYPE_p_Fl_Native_File_Chooser swig_types[80]
#define SWIGTYPE_p_Fl_Native_File_Chooser_Driver swig_types[81]
#define SWIGTYPE_p_Fl_Native_File_Chooser_FLTK_Driver swig_types[82]
#define SWIGTYPE_p_Fl_Nice_Slider swig_types[83]
#define SWIGTYPE_p_Fl_Offscreen swig_types[84]
#define SWIGTYPE_p_Fl_Old_Idle_Handler swig_types[85]
#define SWIGTYPE_p_Fl_Output swig_types[86]
#define SWIGTYPE_p_Fl_Overlay_Window swig_types[87]
#define SWIGTYPE_p_Fl_PDF_File_Surface swig_types[88]
#define SWIGTYPE_p_Fl_PNG_Image swig_types[89]
#define SWIGTYPE_p_Fl_PNM_Image swig_types[90]
#define SWIGTYPE_p_Fl_Pack swig_types[91]
#define SWIGTYPE_p_Fl_Paged_Device swig_types[92]
#define SWIGTYPE_p_Fl_Pixmap swig_types[93]
#define SWIGTYPE_p_Fl_Plugin swig_types[94]
#define SWIGTYPE_p_Fl_Plugin_Manager swig_types[95]
#define SWIGTYPE_p_Fl_Positioner swig_types[96]
#define SWIGTYPE_p_Fl_PostScript_File_Device swig_types[97]
#define SWIGTYPE_p_Fl_Preferences swig_types[98]
#define SWIGTYPE_p_Fl_Preferences__ID swig_types[99]
#define SWIGTYPE_p_Fl_Printer swig_types[100]
#define SWIGTYPE_p_Fl_Progress swig_types[101]
#define SWIGTYPE_p_Fl_RGB_Image swig_types[102]
#define SWIGTYPE_p_Fl_Radio_Button swig_types[103]
#define SWIGTYPE_p_Fl_Radio_Light_Button swig_types[104]
#define SWIGTYPE_p_Fl_Radio_Round_Button swig_types[105]
#define SWIGTYPE_p_Fl_Rect swig_types[106]
#define SWIGTYPE_p_Fl_Region swig_types[107]
#define SWIGTYPE_p_Fl_Repeat_Button swig_types[108]
#define SWIGTYPE_p_Fl_Return_Button swig_types[109]
#define SWIGTYPE_p_Fl_Roller swig_types[110]
#define SWIGTYPE_p_Fl_Round_Button swig_types[111]
#define SWIGTYPE_p_Fl_Round_Clock swig_types[112]
#define SWIGTYPE_p_Fl_SVG_File_Surface swig_types[113]
#define SWIGTYPE_p_Fl_SVG_Image swig_types[114]
#define SWIGTYPE_p_Fl_Scheme_Choice swig_types[115]
#define SWIGTYPE_p_Fl_Screen_Driver swig_types[116]
#define SWIGTYPE_p_Fl_Scroll swig_types[117]
#define SWIGTYPE_p_Fl_Scrollbar swig_types[118]
#define SWIGTYPE_p_Fl_Secret_Input swig_types[119]
#define SWIGTYPE_p_Fl_Select_Browser swig_types[120]
#define SWIGTYPE_p_Fl_Shared_Image swig_types[121]
#define SWIGTYPE_p_Fl_Shortcut_Button swig_types[122]
#define SWIGTYPE_p_Fl_Simple_Counter swig_types[123]
#define SWIGTYPE_p_Fl_Single_Window swig_types[124]
#define SWIGTYPE_p_Fl_Slider swig_types[125]
#define SWIGTYPE_p_Fl_Spinner swig_types[126]
#define SWIGTYPE_p_Fl_Surface_Device swig_types[127]
#define SWIGTYPE_p_Fl_Sys_Menu_Bar swig_types[128]
#define SWIGTYPE_p_Fl_System_Driver swig_types[129]
#define SWIGTYPE_p_Fl_Table swig_types[130]
#define SWIGTYPE_p_Fl_Table_Row swig_types[131]
#define SWIGTYPE_p_Fl_Tabs swig_types[132]
#define SWIGTYPE_p_Fl_Terminal swig_types[133]
#define SWIGTYPE_p_Fl_Text_Buffer swig_types[134]
#define SWIGTYPE_p_Fl_Text_Display swig_types[135]
#define SWIGTYPE_p_Fl_Text_Display__Style_Table_Entry swig_types[136]
#define SWIGTYPE_p_Fl_Text_Editor swig_types[137]
#define SWIGTYPE_p_Fl_Text_Editor__Key_Binding swig_types[138]
#define SWIGTYPE_p_Fl_Text_Selection swig_types[139]
#define SWIGTYPE_p_Fl_Tile swig_types[140]
#define SWIGTYPE_p_Fl_Tiled_Image swig_types[141]
#define SWIGTYPE_p_Fl_Timeout_Handler swig_types[142]
#define SWIGTYPE_p_Fl_Timestamp swig_types[143]
#define SWIGTYPE_p_Fl_Toggle_Button swig_types[144]
#define SWIGTYPE_p_Fl_Tooltip swig_types[145]
#define SWIGTYPE_p_Fl_Tree swig_types[146]
#define SWIGTYPE_p_Fl_Tree_Item swig_types[147]
#define SWIGTYPE_p_Fl_Tree_Item_Array swig_types[148]
#define SWIGTYPE_p_Fl_Tree_Prefs swig_types[149]
#define SWIGTYPE_p_Fl_Valuator swig_types[150]
#define SWIGTYPE_p_Fl_Value_Input swig_types[151]
#define SWIGTYPE_p_Fl_Value_Output swig_types[152]
#define SWIGTYPE_p_Fl_Value_Slider swig_types[153]
#define SWIGTYPE_p_Fl_Vk_Window swig_types[154]
#define SWIGTYPE_p_Fl_Widget swig_types[155]
#define SWIGTYPE_p_Fl_Widget_Surface swig_types[156]
#define SWIGTYPE_p_Fl_Window swig_types[157]
#define SWIGTYPE_p_Fl_Wizard swig_types[158]
#define SWIGTYPE_p_Fl_X swig_types[159]
#define SWIGTYPE_p_Fl_XBM_Image swig_types[160]
#define SWIGTYPE_p_Fl_XPM_Image swig_types[161]
#define SWIGTYPE_p_Fl__TimeoutData swig_types[162]
#define SWIGTYPE_p_Flcc_HueBox swig_types[163]
#define SWIGTYPE_p_Flcc_ValueBox swig_types[164]
#define SWIGTYPE_p_Flcc_Value_Input swig_types[165]
#define SWIGTYPE_p_GLContext swig_types[166]
#define SWIGTYPE_p_ListSelect swig_types[167]
#define SWIGTYPE_p_Scale_Type swig_types[168]
#define SWIGTYPE_p_Style_Table_Entry swig_types[169]
#define SWIGTYPE_p_Tick_Position swig_types[170]
#define SWIGTYPE_p_Window swig_types[171]
#define SWIGTYPE_p_char swig_types[172]
#define SWIGTYPE_p_double swig_types[173]
#define SWIGTYPE_p_f_int_int_int_int_p_q_const__char_p_void__void swig_types[174]
#define SWIGTYPE_p_f_int_int_p_void__void swig_types[175]
#define SWIGTYPE_p_f_int_p_Fl_Text_Editor__int swig_types[176]
#define SWIGTYPE_p_f_p_FILE__int swig_types[177]
#define SWIGTYPE_p_f_p_Fl_File_Chooser_p_void__void swig_types[178]
#define SWIGTYPE_p_f_p_Fl_Tree_Item_p_void__void swig_types[179]
#define SWIGTYPE_p_f_p_Fl_Widget__void swig_types[180]
#define SWIGTYPE_p_f_p_Fl_Widget_long__void swig_types[181]
#define SWIGTYPE_p_f_p_Fl_Widget_p_q_const__char__p_char swig_types[182]
#define SWIGTYPE_p_f_p_Fl_Widget_p_void__void swig_types[183]
#define SWIGTYPE_p_f_p_q_const__char__void swig_types[184]
#define SWIGTYPE_p_f_p_q_const__char_int_int_int__void swig_types[185]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_Anim_GIF_Image swig_types[186]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_BMP_Image swig_types[187]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_Bitmap swig_types[188]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_GIF_Image swig_types[189]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_ICO_Image swig_types[190]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_Image swig_types[191]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_JPEG_Image swig_types[192]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_PNG_Image swig_types[193]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_PNM_Image swig_types[194]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_Pixmap swig_types[195]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_RGB_Image swig_types[196]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_SVG_Image swig_types[197]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_Shared_Image swig_types[198]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_Tiled_Image swig_types[199]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_XBM_Image swig_types[200]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_XPM_Image swig_types[201]
#define SWIGTYPE_p_f_p_void_int_int_int_int__void swig_types[202]
#define SWIGTYPE_p_f_unsigned_int__void swig_types[203]
#define SWIGTYPE_p_f_unsigned_int_unsigned_int_int_int__unsigned_int swig_types[204]
#define SWIGTYPE_p_fl_uintptr_t swig_types[205]
#define SWIGTYPE_p_float swig_types[206]
#define SWIGTYPE_p_int swig_types[207]
#define SWIGTYPE_p_p_Fl_Adjuster swig_types[208]
#define SWIGTYPE_p_p_Fl_BMP_Image swig_types[209]
#define SWIGTYPE_p_p_Fl_Box swig_types[210]
#define SWIGTYPE_p_p_Fl_Browser swig_types[211]
#define SWIGTYPE_p_p_Fl_Browser_ swig_types[212]
#define SWIGTYPE_p_p_Fl_Button swig_types[213]
#define SWIGTYPE_p_p_Fl_Chart swig_types[214]
#define SWIGTYPE_p_p_Fl_Check_Browser swig_types[215]
#define SWIGTYPE_p_p_Fl_Check_Button swig_types[216]
#define SWIGTYPE_p_p_Fl_Choice swig_types[217]
#define SWIGTYPE_p_p_Fl_Clock swig_types[218]
#define SWIGTYPE_p_p_Fl_Clock_Output swig_types[219]
#define SWIGTYPE_p_p_Fl_Color_Chooser swig_types[220]
#define SWIGTYPE_p_p_Fl_Counter swig_types[221]
#define SWIGTYPE_p_p_Fl_Dial swig_types[222]
#define SWIGTYPE_p_p_Fl_Double_Window swig_types[223]
#define SWIGTYPE_p_p_Fl_File_Browser swig_types[224]
#define SWIGTYPE_p_p_Fl_File_Input swig_types[225]
#define SWIGTYPE_p_p_Fl_Fill_Dial swig_types[226]
#define SWIGTYPE_p_p_Fl_Fill_Slider swig_types[227]
#define SWIGTYPE_p_p_Fl_Flex swig_types[228]
#define SWIGTYPE_p_p_Fl_Float_Input swig_types[229]
#define SWIGTYPE_p_p_Fl_Gl_Window swig_types[230]
#define SWIGTYPE_p_p_Fl_Grid swig_types[231]
#define SWIGTYPE_p_p_Fl_Group swig_types[232]
#define SWIGTYPE_p_p_Fl_Help_View swig_types[233]
#define SWIGTYPE_p_p_Fl_Hold_Browser swig_types[234]
#define SWIGTYPE_p_p_Fl_Hor_Fill_Slider swig_types[235]
#define SWIGTYPE_p_p_Fl_Hor_Nice_Slider swig_types[236]
#define SWIGTYPE_p_p_Fl_Hor_Slider swig_types[237]
#define SWIGTYPE_p_p_Fl_Hor_Value_Slider swig_types[238]
#define SWIGTYPE_p_p_Fl_ICO_Image swig_types[239]
#define SWIGTYPE_p_p_Fl_Input swig_types[240]
#define SWIGTYPE_p_p_Fl_Input_ swig_types[241]
#define SWIGTYPE_p_p_Fl_Input_Choice swig_types[242]
#define SWIGTYPE_p_p_Fl_Int_Input swig_types[243]
#define SWIGTYPE_p_p_Fl_JPEG_Image swig_types[244]
#define SWIGTYPE_p_p_Fl_Light_Button swig_types[245]
#define SWIGTYPE_p_p_Fl_Line_Dial swig_types[246]
#define SWIGTYPE_p_p_Fl_Menu_ swig_types[247]
#define SWIGTYPE_p_p_Fl_Menu_Bar swig_types[248]
#define SWIGTYPE_p_p_Fl_Menu_Button swig_types[249]
#define SWIGTYPE_p_p_Fl_Menu_Window swig_types[250]
#define SWIGTYPE_p_p_Fl_Multi_Browser swig_types[251]
#define SWIGTYPE_p_p_Fl_Multiline_Input swig_types[252]
#define SWIGTYPE_p_p_Fl_Multiline_Output swig_types[253]
#define SWIGTYPE_p_p_Fl_Nice_Slider swig_types[254]
#define SWIGTYPE_p_p_Fl_Output swig_types[255]
#define SWIGTYPE_p_p_Fl_Overlay_Window swig_types[256]
#define SWIGTYPE_p_p_Fl_PNG_Image swig_types[257]
#define SWIGTYPE_p_p_Fl_PNM_Image swig_types[258]
#define SWIGTYPE_p_p_Fl_Pack swig_types[259]
#define SWIGTYPE_p_p_Fl_Positioner swig_types[260]
#define SWIGTYPE_p_p_Fl_Progress swig_types[261]
#define SWIGTYPE_p_p_Fl_RGB_Image swig_types[262]
#define SWIGTYPE_p_p_Fl_Radio_Button swig_types[263]
#define SWIGTYPE_p_p_Fl_Radio_Light_Button swig_types[264]
#define SWIGTYPE_p_p_Fl_Radio_Round_Button swig_types[265]
#define SWIGTYPE_p_p_Fl_Repeat_Button swig_types[266]
#define SWIGTYPE_p_p_Fl_Return_Button swig_types[267]
#define SWIGTYPE_p_p_Fl_Roller swig_types[268]
#define SWIGTYPE_p_p_Fl_Round_Button swig_types[269]
#define SWIGTYPE_p_p_Fl_Round_Clock swig_types[270]
#define SWIGTYPE_p_p_Fl_SVG_Image swig_types[271]
#define SWIGTYPE_p_p_Fl_Scheme_Choice swig_types[272]
#define SWIGTYPE_p_p_Fl_Scroll swig_types[273]
#define SWIGTYPE_p_p_Fl_Scrollbar swig_types[274]
#define SWIGTYPE_p_p_Fl_Secret_Input swig_types[275]
#define SWIGTYPE_p_p_Fl_Select_Browser swig_types[276]
#define SWIGTYPE_p_p_Fl_Shared_Image swig_types[277]
#define SWIGTYPE_p_p_Fl_Shortcut_Button swig_types[278]
#define SWIGTYPE_p_p_Fl_Simple_Counter swig_types[279]
#define SWIGTYPE_p_p_Fl_Single_Window swig_types[280]
#define SWIGTYPE_p_p_Fl_Slider swig_types[281]
#define SWIGTYPE_p_p_Fl_Spinner swig_types[282]
#define SWIGTYPE_p_p_Fl_Sys_Menu_Bar swig_types[283]
#define SWIGTYPE_p_p_Fl_Table swig_types[284]
#define SWIGTYPE_p_p_Fl_Table_Row swig_types[285]
#define SWIGTYPE_p_p_Fl_Tabs swig_types[286]
#define SWIGTYPE_p_p_Fl_Terminal swig_types[287]
#define SWIGTYPE_p_p_Fl_Text_Display swig_types[288]
#define SWIGTYPE_p_p_Fl_Text_Editor swig_types[289]
#define SWIGTYPE_p_p_Fl_Tile swig_types[290]
#define SWIGTYPE_p_p_Fl_Toggle_Button swig_types[291]
#define SWIGTYPE_p_p_Fl_Tree swig_types[292]
#define SWIGTYPE_p_p_Fl_Valuator swig_types[293]
#define SWIGTYPE_p_p_Fl_Value_Input swig_types[294]
#define SWIGTYPE_p_p_Fl_Value_Output swig_types[295]
#define SWIGTYPE_p_p_Fl_Value_Slider swig_types[296]
#define SWIGTYPE_p_p_Fl_Widget swig_types[297]
#define SWIGTYPE_p_p_Fl_Window swig_types[298]
#define SWIGTYPE_p_p_Fl_Wizard swig_types[299]
#define SWIGTYPE_p_p_Flcc_HueBox swig_types[300]
#define SWIGTYPE_p_p_Flcc_ValueBox swig_types[301]
#define SWIGTYPE_p_p_Flcc_Value_Input swig_types[302]
#define SWIGTYPE_p_p_ListSelect swig_types[303]
#define SWIGTYPE_p_p_char swig_types[304]
#define SWIGTYPE_p_p_p_char swig_types[305]
#define SWIGTYPE_p_p_p_dirent swig_types[306]
#define SWIGTYPE_p_p_void swig_types[307]
#define SWIGTYPE_p_short swig_types[308]
#define SWIGTYPE_p_std__vectorT_Fl__TimeoutData_t swig_types[309]
#define SWIGTYPE_p_unsigned_char swig_types[310]
#define SWIGTYPE_p_unsigned_int swig_types[311]
#define SWIGTYPE_p_unsigned_long swig_types[312]
#define SWIGTYPE_p_unsigned_short swig_types[313]
#define SWIGTYPE_p_void swig_types[314]
#define SWIGTYPE_p_wchar_t swig_types[315]
#define SWIGTYPE_p_window_menu_style_enum swig_types[316]
static swig_type_info *swig_types[318];
static swig_module_info swig_module = {swig_types, 317, 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):= _fltk.so
  ------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_init    PyInit__fltk

#else
#  define SWIG_init    init_fltk

#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) (void *)((const void *)(a)) 
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(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;      
    }
  };
}


// Ugly and potentially dangerous hack to enable compiling
// extensions with Python2.4 and later using MinGW. Library
// msvcr71 does not declare the below symbol anymore, and 
// msvcrt should not be linked with!
#ifdef __MINGW32_VERSION
short ** _imp___ctype = 0;
#endif


#include "FL/fl_types.h"


#include "FL/fl_attr.h"




#include "FL/Enumerations.H"


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


#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 <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_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 = (int)(v);
    }
  }  
  return res;
}


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 = (unsigned int)(v);
    }
  }  
  return res;
}


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


  #define SWIG_From_double   PyFloat_FromDouble 


/* 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 = (float)(v);
    }
  }  
  return res;
}


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


#include "FL/Fl_Image.H"


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


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


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


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


  #define SWIG_From_long   PyInt_FromLong 


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


#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((long)(value));
}
#endif


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


#include <FL/Fl.H>
#include "FL/Fl_Widget.H"


#include <string>


#include "CallbackStruct.h"
#include <FL/Fl_Button.H>

  //static PyObject *my_pycallback = NULL;
  static void Fl_Widget_PythonCallBack(Fl_Widget *widget, void *clientdata)
    {
      PyObject *func, *arglist;
      PyObject *result;
      PyObject *obj = 0;
      CallbackStruct* cb = (CallbackStruct*)clientdata;

      // This is the function .... 
      func = cb->func;

      if (cb->widget != 0) {
        // the parent widget
        obj = (PyObject *)( ((CallbackStruct *)clientdata)->widget);
      }
      else if (cb->type != 0) {
        // this is the type of widget
        swig_type_info *descr = (swig_type_info *)cb->type;
        if (descr != 0) {
          //printf("success\n");
          obj = SWIG_NewPointerObj(widget, (swig_type_info *)descr, 0);
        }
      }
      if (obj == 0) {
        // generic fallback
        obj = SWIG_NewPointerObj(widget, SWIGTYPE_p_Fl_Widget, 0);
      }

      if (((CallbackStruct *)clientdata)->data)
	{
	  arglist = Py_BuildValue("(OO)", obj, (PyObject *)(((CallbackStruct *)clientdata)->data) ); 
	}
      else
	{
	  arglist = Py_BuildValue("(O)", obj ); 
	}

      result =  PyObject_CallObject(func, arglist);
   
      //Py_XDECREF(arglist);                           // Trash arglist
      Py_XDECREF(result);
      PyObject *error = PyErr_Occurred();
      {
	if (error != NULL) {
	  throw Swig::DirectorMethodException();
	}
      }
      //if (PyErr_Occurred())
      //{
      //  PyErr_Print();
      //}
   
      return /*void*/;
    }
  

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 = (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 = (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_AsVal_bool (PyObject *obj, bool *val)
{
  int r;
  if (!PyBool_Check(obj))
    return SWIG_ERROR;
  r = PyObject_IsTrue(obj);
  if (r == -1)
    return SWIG_ERROR;
  if (val) *val = r ? true : false;
  return SWIG_OK;
}


SWIGINTERNINLINE PyObject*
  SWIG_From_bool  (bool value)
{
  return PyBool_FromLong(value ? 1 : 0);
}


SWIGINTERNINLINE PyObject *
SWIG_From_unsigned_SS_char  (unsigned char value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}


SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
  if (carray) {
    if (size > INT_MAX) {
      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
      return pchar_descriptor ? 
	SWIG_InternalNewPointerObj((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, (Py_ssize_t)(size));
#else
      return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
#endif
#else
      return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
#endif
    }
  } else {
    return SWIG_Py_Void();
  }
}


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

SWIGINTERN void Fl_Widget_init_type(Fl_Widget *self,char *Fl_Widget){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Widget, strlen(Fl_Widget));
    self->user_data(cb);
  }
SWIGINTERN void Fl_Widget_draw_label__SWIG_1(Fl_Widget *self){
   int X = self->x()+Fl::box_dx(self->box());
   int W = self->w()-Fl::box_dw(self->box());
   if (W > 11 && self->align()&(FL_ALIGN_LEFT|FL_ALIGN_RIGHT)) {X += 3; W -= 6;}
   self->draw_label(X, self->y()+Fl::box_dy(self->box()), W, self->h()-Fl::box_dh(self->box()),self->align());
 }
SWIGINTERN void Fl_Widget_draw_backdrop(Fl_Widget *self){
   if (self->align() & FL_ALIGN_IMAGE_BACKDROP) {
    const Fl_Image *img = self->image();
    // if there is no image, we will not draw the deimage either
    if (img && self->deimage() && !self->active_r())
      img = self->deimage();
    if (img) 
      ((Fl_Image*)img)->draw(self->x()+(self->w()-img->w())/2, self->y()+(self->h()-img->h())/2);
   }
 }
SWIGINTERN void Fl_Widget_callback__SWIG_6(Fl_Widget *self,PyObject *PyFunc,PyObject *PyWidget,PyObject *PyData=0){
      //CallbackStruct *cb = 0;
      CallbackStruct *cb = (CallbackStruct*)self->user_data();

      if (cb) {
	cb->func = PyFunc;
	cb->widget = PyWidget;
	if (PyData) {
	  cb->data = PyData;
	}
	cb->widget = PyWidget;
      }
      else
	cb = new CallbackStruct( PyFunc, PyData, PyWidget );

      // Add a reference to new callback
      Py_INCREF(PyFunc);			
      Py_XINCREF(PyData);
      Py_XINCREF(PyWidget);

      self->callback(Fl_Widget_PythonCallBack, (void *)cb);

    
    }
SWIGINTERN void Fl_Widget_user_data__SWIG_1(Fl_Widget *self,PyObject *PyData){
      // Add a reference to new callback
      Py_XINCREF(PyData);
	
      CallbackStruct *cb = (CallbackStruct*)self->user_data();
      if (cb == NULL) {
	cb = new CallbackStruct(0, PyData, (PyObject*)0);
	self->user_data((void *)cb);
      }
      else {
	if (cb->data != NULL)
	  Py_XDECREF(cb->data);
	cb->data = PyData;
      }
    
    }
SWIGINTERN PyObject *Fl_Widget_user_data__SWIG_2(Fl_Widget *self){
    PyObject *obj = 0;
    CallbackStruct *cb = (CallbackStruct*)self->user_data();
    if (cb) {
      if (cb->data) {
	obj = (PyObject*)cb->data;

	Py_XINCREF(obj);
	return obj;
      }
    }
    // nothing found
    Py_RETURN_NONE;
  }

#include "FL/Fl_Widget_Surface.H"


#include "FL/Fl_Group.H"

SWIGINTERN void Fl_Group_init_type(Fl_Group *self,char *Fl_Group){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Group, strlen(Fl_Group));
    self->user_data(cb);
  }

#include "FL/Fl_Browser_.H"

SWIGINTERN void Fl_Browser__init_type(Fl_Browser_ *self,char *Fl_Browser_){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Browser_, strlen(Fl_Browser_));
    self->user_data(cb);
  }
SWIGINTERN Fl_Scrollbar *Fl_Browser__getScrollbar(Fl_Browser_ *self){
		return &(self->scrollbar);
	}
SWIGINTERN Fl_Scrollbar *Fl_Browser__getHScrollbar(Fl_Browser_ *self){
		return &(self->hscrollbar);
	}

#include "FL/Fl_Browser.H"


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


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


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 = (char)(v);
      } else {
	res = SWIG_OverflowError;
      }
    }
  }
  return res;
}

SWIGINTERN void Fl_Browser_init_type(Fl_Browser *self,char *Fl_Browser){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Browser, strlen(Fl_Browser));
    self->user_data(cb);
  }
SWIGINTERN void Fl_Browser_add(Fl_Browser *self,char const *text,PyObject *data=0){
      Py_XINCREF(data);
      if (data) {
	void *tmp = (void *) 0 ;
        if ((SWIG_ConvertPtr(data,(void **) &tmp, 0, SWIG_POINTER_EXCEPTION | 0 )) == -1) {
	  PyErr_Clear();
	  // not a C object, just add it as is
	  self->add( text, data );
	}
	else {
	  // found C object, add it instead of data
	  self->add( text, tmp );
	}
      }
      else
	self->add( text );
    }
SWIGINTERN void Fl_Browser_insert(Fl_Browser *self,int index,char const *text,PyObject *data=0){
      Py_XINCREF(data);
      //self->insert( index, text, data);
      if (data) {
	void *tmp = (void *) 0 ;
	if ((SWIG_ConvertPtr(data,(void **) &tmp, 0, SWIG_POINTER_EXCEPTION | 0 )) == -1) {
	  PyErr_Clear();
	  // not a C object, just add it as is
	  self->insert( index, text, data );
	}
	else {
	  // found C object, add it instead of data
	  self->insert( index, text, tmp );
	}
      }
      else
	self->insert( index, text, 0 );
    }
SWIGINTERN PyObject *Fl_Browser_get_data(Fl_Browser *self,int index){
	PyObject *data = (PyObject *)(self->data(index));
	Py_XINCREF(data);
	return (PyObject *)data;
}
SWIGINTERN PyObject *Fl_Browser_data(Fl_Browser *self,int index,PyObject *data=0){
     //Py_XDECREF((PyObject *)(self->data(index)));
     Py_XINCREF(data);

     if (data) {
       void *tmp = (void *) 0 ;
       if ((SWIG_ConvertPtr(data,(void **) &tmp, 0, SWIG_POINTER_EXCEPTION | 0 )) == -1) {
	 PyErr_Clear();
	 // not a C object, just add it as is
	 self->data( index, data );
       }
       else {
	 // found C object, add it instead of data
	 self->data( index, tmp );
       }
     }
     else {
       PyObject *data = (PyObject *)(self->data(index));
       Py_XINCREF(data);
       return (PyObject *)data;
     }

     Py_XINCREF(Py_None);
     return Py_None;
   }
SWIGINTERN void Fl_Browser_column_widths__SWIG_1(Fl_Browser *self,PyObject *widths){
    //static const int no_cols[] = { 0 };

    if (PyTuple_Check(widths))
    {
       // the following lines should not be necessary?
       // commented out by ah, June 15, 2003	
       //if (self->column_widths())
       //{
       //   // FLTK has its own no_cols...
       //   if (*self->column_widths())
       //   {
       //      //delete [] self->column_widths();
       //      self->column_widths(no_cols);
       //   }
       //}

       Py_ssize_t sz = PyTuple_Size(widths);
       if (sz)
       {
          int* cw = new int[sz+1];
          cw[sz] = 0;
          for (int k = 0; k<sz; ++k)
          {
             PyObject *obj = PyTuple_GetItem(widths, k);
             if (!obj)
             {
                delete[] cw;
                return;
             }

             if (!PyInt_Check(obj))
             {
                delete[] cw;
                PyErr_SetString(PyExc_TypeError, "Integer needed");
                return;
             }

             cw[k] = PyInt_AsLong(obj);
          }

          self->column_widths(cw);
       }
       else
       {
          // nothing to do
       }
    }
    else
    {
       PyErr_SetString(PyExc_TypeError, "Not a tuple");
       return;
    }
}

#ifdef ANY
#undef ANY
#endif

#include "FL/Fl_File_Browser.H"

enum DIR_SEARCH {
    FL_ALPHASORT,
    FL_CASEALPHASORT,
    FL_CASENUMERICSORT,
    FL_NUMERICSORT
  };

SWIGINTERN void Fl_File_Browser_init_type(Fl_File_Browser *self,char *Fl_File_Browser){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_File_Browser, strlen(Fl_File_Browser));
    self->user_data(cb);
  }
SWIGINTERN int Fl_File_Browser_load_new(Fl_File_Browser *self,PyObject *dObj,PyObject *sObj){
    //char *directory=SWIG_Python_str_AsChar(dObj);
    const char *directory=PyUnicode_AsUTF8(dObj);
    int sort=PyInt_AsLong(sObj);
    int result = -1;

    switch (sort) {
    case FL_ALPHASORT:
      result = self->load(directory, fl_alphasort);
      break;
    case FL_CASEALPHASORT:
      result = self->load(directory, fl_casealphasort);
      break;
    case FL_CASENUMERICSORT:
      result = self->load(directory, fl_casenumericsort);
      break;
    case FL_NUMERICSORT:
      result = self->load(directory, fl_numericsort);
      break;
    default:
      break;
    }

    return result;
  }


#include "FL/Fl_File_Icon.H"


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 = (short)(v);
    }
  }  
  return res;
}


#include "FL/Fl_File_Chooser.H"


#include "CallbackStruct.h"
#include <FL/Fl_Button.H>

  //static PyObject *my_pycallback = NULL;
  static void Fl_File_Chooser_PythonCallBack(Fl_File_Chooser *widget, void *clientdata)
    {
      PyObject *func, *arglist;
      PyObject *result;
      PyObject *obj = 0;
      CallbackStruct* cb = (CallbackStruct*)clientdata;

      // This is the function .... 
      func = cb->func;

      if (cb->widget != 0) {
        // the parent widget
        obj = (PyObject *)( ((CallbackStruct *)clientdata)->widget);
      }
      else if (cb->type != 0) {
        // this is the type of widget
        swig_type_info *descr = (swig_type_info *)cb->type;
        if (descr != 0) {
          //printf("success\n");
          obj = SWIG_NewPointerObj(widget, (swig_type_info *)descr, 0);
        }
      }
      if (obj == 0) {
        // generic fallback
        obj = SWIG_NewPointerObj(widget, SWIGTYPE_p_Fl_File_Chooser, 0);
      }

      if (((CallbackStruct *)clientdata)->data)
	{
	  arglist = Py_BuildValue("(OO)", obj, (PyObject *)(((CallbackStruct *)clientdata)->data) ); 
	}
      else
	{
	  arglist = Py_BuildValue("(O)", obj ); 
	}

      result =  PyObject_CallObject(func, arglist);
   
      //Py_XDECREF(arglist);                           // Trash arglist
      Py_XDECREF(result);
      PyObject *error = PyErr_Occurred();
      {
	if (error != NULL) {
	  throw Swig::DirectorMethodException();
	}
      }
      //if (PyErr_Occurred())
      //{
      //  PyErr_Print();
      //}
   
      return /*void*/;
    }
  
SWIGINTERN void Fl_File_Chooser_callback__SWIG_1(Fl_File_Chooser *self,PyObject *PyFunc,PyObject *PyWidget,PyObject *PyData=0){
      //CallbackStruct *cb = 0;
      CallbackStruct *cb = (CallbackStruct*)self->user_data();

      if (cb) {
	cb->func = PyFunc;
	cb->widget = PyWidget;
	if (PyData) {
	  cb->data = PyData;
	}
	cb->widget = PyWidget;
      }
      else
	cb = new CallbackStruct( PyFunc, PyData, PyWidget );

      // Add a reference to new callback
      Py_INCREF(PyFunc);			
      Py_XINCREF(PyData);
      Py_XINCREF(PyWidget);

      self->callback(Fl_File_Chooser_PythonCallBack, (void *)cb);

    
    }
SWIGINTERN void Fl_File_Chooser_user_data__SWIG_0(Fl_File_Chooser *self,PyObject *PyData){
      // Add a reference to new callback
      Py_XINCREF(PyData);
	
      CallbackStruct *cb = (CallbackStruct*)self->user_data();
      if (cb == NULL) {
	cb = new CallbackStruct(0, PyData, (PyObject*)0);
	self->user_data((void *)cb);
      }
      else {
	if (cb->data != NULL)
	  Py_XDECREF(cb->data);
	cb->data = PyData;
      }
    
    }
SWIGINTERN PyObject *Fl_File_Chooser_user_data__SWIG_1(Fl_File_Chooser *self){
    PyObject *obj = 0;
    CallbackStruct *cb = (CallbackStruct*)self->user_data();
    if (cb) {
      if (cb->data) {
	obj = (PyObject*)cb->data;

	Py_XINCREF(obj);
	return obj;
      }
    }
    // nothing found
    Py_RETURN_NONE;
  }

#include "FL/Fl.H"
#include <signal.h>


// called by FLTK when idle
PyObject *registeredDoIDle = 0;
void pyFLTK_idleCallback(void *data)
{
        PyObject *arglist;
        PyObject *result;
        arglist = Py_BuildValue("()");       // Build argument list
        result = PyObject_CallObject(registeredDoIDle, arglist);   // Call Python
        Py_DECREF(arglist);                           // Trash arglist
        //result = PyObject_CallObject(func,(PyObject *)0);     // Call Python
        Py_XDECREF(result);
		if (PyErr_Occurred())
		{
			PyErr_Print();
		}
}


// turn on/off idle callback into the Python interpreter	
void pyFLTK_controlIdleCallbacks(int enable)
{
	if (enable)
	{
		Fl::add_idle(pyFLTK_idleCallback, 0);
	}
	else
	{
		Fl::remove_idle(pyFLTK_idleCallback);
	}
}


// called by the initialization code in the module - 
// not meant for user consumption
PyObject *registerDoIdle(PyObject *self, PyObject *args) 
{
	PyArg_ParseTuple( args, "O", &registeredDoIDle);
	if (!PyCallable_Check(registeredDoIDle)) 
	{
		PyErr_SetString(PyExc_TypeError, "Need a callable object!");
	}
	else
	{
		Py_INCREF(registeredDoIDle);
	}
	Py_INCREF(Py_None);
	return Py_None;
}





     
#include "CallbackStruct.h"

struct timeout_link {
  CallbackStruct *handle;
  timeout_link *next;
};

static timeout_link *py_timeout_funcs = NULL;


void pyFLTK_timeoutCallback(void *data)
{
  CallbackStruct *cb =  (CallbackStruct *)data;
  PyObject *result;

  if (py_timeout_funcs != NULL) {
    timeout_link *l, *p;
    for (l = py_timeout_funcs, p = 0; l && l->handle != cb; p = l, l = l->next);
    
    if (l) {
      // Found it, so remove it from the list...
      if (p) 
	p->next = l->next;
      else 
	py_timeout_funcs = l->next;
      
      // And free the record...
      delete l;
    }
  }

  // check for NULL arguments
  PyObject *args = NULL;
  if (cb->data) {
    args = Py_BuildValue("(O)", cb->data);
    if (PyErr_Occurred())
      {  
	PyErr_Print();
      }
  }	
  result = PyObject_CallObject(cb->func, args);     // Call Python
  if (PyErr_Occurred())
    {
      PyErr_Print();
    }
  Py_DECREF(cb->func); 
  Py_XDECREF(cb->data);
  Py_XDECREF(args);
  Py_XDECREF(result);
  delete cb;
  if (PyErr_Occurred())
    {
      PyErr_Print();
    }
}

PyObject *Fl_add_timeout(PyObject *self, PyObject *args) 
{
  float numSeconds; 
  PyObject *func = 0;
  PyObject *data = 0;
  
  PyArg_ParseTuple( args, "fO|O", &numSeconds, &func, &data);
  if (!PyCallable_Check(func)) 
    {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
    }
  else
    {
      CallbackStruct *cb = new CallbackStruct( func, data, (PyObject*)0 );
      // add reference to list
      timeout_link *t = new timeout_link;
      t->handle = cb;
      t->next = py_timeout_funcs;
      py_timeout_funcs = t;
      // function call
      Py_INCREF(func);
      Py_XINCREF(data);
      Fl::add_timeout( numSeconds, pyFLTK_timeoutCallback, cb);
    }
  
  Py_INCREF(Py_None);
  return Py_None;
}

PyObject *Fl_repeat_timeout(PyObject *self, PyObject *args) 
{
  float numSeconds; 
  PyObject *func = 0;
  PyObject *data = 0;
  
  PyArg_ParseTuple( args, "fO|O", &numSeconds, &func, &data);
  if (!PyCallable_Check(func)) 
    {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
    }
  else
    {
      CallbackStruct *cb = new CallbackStruct( func, data, (PyObject*)0 );
      // add reference to list
      timeout_link *t = new timeout_link;
      t->handle = cb;
      t->next = py_timeout_funcs;
      py_timeout_funcs = t;
      // function call
      Py_INCREF(func);
      Py_XINCREF(data);
      Fl::repeat_timeout( numSeconds, pyFLTK_timeoutCallback, cb);
    }
  
  Py_INCREF(Py_None);
  return Py_None;
}

PyObject *Fl_remove_timeout(PyObject *self, PyObject *args) 
{
  PyObject *func = 0;
  PyObject *data = 0;
  PyArg_ParseTuple( args, "O|O", &func, &data);
  if (!PyCallable_Check(func)) 
    {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
    }
  else
    {
      //printf("Fl_Remove_timeout callable found\n");
      //CallbackStruct *cb = new CallbackStruct( func, data, (PyObject*)0 );
      //Fl::remove_timeout( pyFLTK_timeoutCallback, cb);
      //Py_DECREF(cb->func); 
      //Py_XDECREF(cb->data);

      if (py_timeout_funcs != NULL) 
      {
	timeout_link *l, *p;

	l = py_timeout_funcs;
	p = 0;
	while (l != NULL)
	{
	  // compare the functions
	  if( PyObject_RichCompareBool( l->handle->func, func, Py_EQ ) == 1 )
	    {
	      // if needed, also compare data
	      if (!(data == NULL || ( PyObject_RichCompareBool( l->handle->data, data, Py_EQ ) == 1)))
		{
		  //printf("Fl_Remove_timeout incomplete match\n");
		  p = l;
		  l = l->next;
		  continue;
		}
	      //printf("Removing: l = %xd, handle = %xd; func = %xd; data = %xd\n", l, l->handle, l->handle->func, l->handle->data);
	      // Found it, so remove it from the list...
	      if (p) 
		p->next = l->next;
	      else {
		py_timeout_funcs = l->next;
	      }
	      Fl::remove_timeout( pyFLTK_timeoutCallback, l->handle);
	      Py_DECREF(l->handle->func);
	      Py_XDECREF(l->handle->data);

	      // And free the record...
	      l->handle = NULL;
	      l->next = NULL;
	      delete l;
	      l = NULL;
	    }
	  if (l) {
	    p = l;
	    l = l->next;
	  }
	  else {
	    l = py_timeout_funcs;
	    p = 0;
	  }
	}
      }
    }
  Py_INCREF(Py_None);
  return Py_None;
}




struct fd_link {
       int fd;
       PyObject *func;
       PyObject *data;
       fd_link *next;
};

static fd_link *py_fd_funcs = NULL;

void pyFLTK_fdCallback(int fd, void* data) {
     // check for NULL arguments
     PyObject *args = NULL;

     // loop through Python handler
     for (const fd_link *hl = py_fd_funcs; hl; hl = hl->next) {
       if (hl->fd == fd) {
         if (hl->data == NULL)
     	   args = Py_BuildValue("(i)", fd);
         else
           args = Py_BuildValue("(iO)", fd, hl->data);
         PyObject_CallObject(hl->func, args);     // Call Python
         if (PyErr_Occurred())
	 {
	   PyErr_Print();
	 }
         break;
       }	 
     }

     Py_XDECREF(args);
   }

PyObject *Fl_add_fd(PyObject *self, PyObject *args) 
   {
     int fd;
     int when;
     bool long_signature = true;
     PyObject *func = 0;
     PyObject *data = 0;

     PyArg_ParseTuple( args, "iiO|O", &fd, &when, &func, &data);
     if (PyErr_Occurred())
     {
       PyErr_Clear();
       PyArg_ParseTuple( args, "iO|O", &fd, &func, &data);
       long_signature = false;
       if (PyErr_Occurred())
       {
         PyErr_Print();
       }
     }
     if (!PyCallable_Check(func)) 
       {
	       PyErr_SetString(PyExc_TypeError, "Need a callable object!");
       }
     else
       {
         fd_link *cb = py_fd_funcs;
	 while (cb != NULL) {
	   if (cb->fd == fd) {
	     Py_INCREF(cb->func);
	     Py_XINCREF(cb->data);
	     cb->func = func;
	     cb->data = data;
	     break;
	   }
	   cb = cb->next;
	 }
	 if (cb == NULL) {
	   // only add one callback, actual callback list is kept in Python
     if (long_signature)
	     Fl::add_fd(fd, when, (Fl_FD_Handler)pyFLTK_fdCallback);
     else
       Fl::add_fd(fd, (Fl_FD_Handler)pyFLTK_fdCallback);

	   // add the python callback
	   fd_link *cb = new fd_link;
	   cb->next = py_fd_funcs;
	   cb->fd = fd;
	   cb->func = func;
	   cb->data = data;
	   py_fd_funcs = cb;
	   Py_INCREF(func);
	   Py_XINCREF(data);
	 }
       }

     Py_INCREF(Py_None);
     return Py_None;
   }

PyObject * Fl_remove_fd(PyObject *self, PyObject *args) 
   {
     int fd;
     PyArg_ParseTuple( args, "i", &fd);
     if (PyErr_Occurred())
     {
       PyErr_Print();
     }

     if (py_fd_funcs != NULL) {
       fd_link *l, *p;

       // Search for the handler in the list...
       for (l = py_fd_funcs, p = 0; l && l->fd != fd; p = l, l = l->next);

       if (l) {
	 // Found it, so remove it from the list...
	 if (p) 
	   p->next = l->next;
	 else 
	   py_fd_funcs = l->next;

	 // reference count
	 Py_DECREF(l->func);
	 Py_XDECREF(l->data);

	 // And free the record...
	 delete l;

	 // remove the fltk handler to avoid memory leaks
	 Fl::remove_fd(fd);
       }
     }
     Py_INCREF(Py_None);
     return Py_None;
   }



struct handler_link {
  //int (*handle)(int);
  PyObject *handle;
  handler_link *next;
};

static handler_link *py_handler_funcs = NULL;

int pyFLTK_handlerCallback(int data)
   {
     PyObject *result = NULL;

     // check for NULL arguments
     PyObject *args = NULL;
     args = Py_BuildValue("(i)", data);
     if (PyErr_Occurred())
       {  
	 PyErr_Print();
       }

     // loop through Python handler
     int c_result = 0;
     for (const handler_link *hl = py_handler_funcs; hl; hl = hl->next) {
       result = PyObject_CallObject(hl->handle, args);     // Call Python
       if (PyErr_Occurred())
	 {
	   PyErr_Print();
	 }

       
       if (result){
	 SWIG_AsVal_int(result, &c_result);
       }
       if (c_result) break;
     }

     Py_XDECREF(args);
     Py_XDECREF(result);

     return c_result;
   }

PyObject *Fl_add_handler(PyObject *self, PyObject *args) 
   {
     PyObject *func = 0;

     PyArg_ParseTuple( args, "O", &func);
     if (!PyCallable_Check(func)) 
       {
	 PyErr_SetString(PyExc_TypeError, "Need a callable object!");
       }
     else
       {
	 if (py_handler_funcs == NULL) {
	   // only add one callback, actual callback list is kept in Python
	   Fl::add_handler(pyFLTK_handlerCallback);
	 }
	 // add the python callback
	 handler_link *cb = new handler_link;
	 cb->next = py_handler_funcs;
	 cb->handle = func;
	 py_handler_funcs = cb;
	 Py_INCREF(func);
       }

     Py_INCREF(Py_None);
     return Py_None;
   }

PyObject * Fl_remove_handler(PyObject *self, PyObject *args) 
   {
     PyObject *func = 0;
     PyArg_ParseTuple( args, "O", &func);

     if (py_handler_funcs != NULL) {
       handler_link *l, *p;

       // Search for the handler in the list...
       for (l = py_handler_funcs, p = 0; l && l->handle != func; p = l, l = l->next);

       if (l) {
	 // Found it, so remove it from the list...
	 if (p) 
	   p->next = l->next;
	 else 
	   py_handler_funcs = l->next;

	 // reference count
	 Py_DECREF(l->handle);

	 // And free the record...
	 delete l;
       }
       // was this the last one?
       if (py_handler_funcs == NULL) {
	 // remove the fltk handler to avoid memory leaks
	 Fl::remove_handler(pyFLTK_handlerCallback);
       }
     }
     Py_INCREF(Py_None);
     return Py_None;
   }




 


struct check_link {
  //int (*handle)(int);
  PyObject *handle;
  PyObject *args;
  check_link *next;
};

static check_link *py_check_funcs = NULL;

void pyFLTK_checkCallback(void *data)
   {
     PyObject *result = NULL;

     

     // loop through Python handler
     for (const check_link *hl = py_check_funcs; hl; hl = hl->next) {
       // check for NULL arguments
       PyObject *args = NULL;
       if (hl->args) {
	 args = Py_BuildValue("(O)", hl->args);
       }
       else {
       	 args = Py_BuildValue("()");
       }
       if (PyErr_Occurred()) {  
	   PyErr_Print();
       }
       result = PyObject_CallObject(hl->handle, args);     // Call Python
       if (PyErr_Occurred())
	 {
	   PyErr_Print();
	 }
       Py_XDECREF(args);
       Py_XDECREF(result);
     }
   }

PyObject *Fl_add_check(PyObject *self, PyObject *args) 
   {
     PyObject *func = 0;
     PyObject *data = 0;

     PyArg_ParseTuple( args, "O|O", &func, &data);
     if (!PyCallable_Check(func)) 
       {
	 PyErr_SetString(PyExc_TypeError, "Fl.add_check: need a callable object!");
       }
     else
       {
	 if (py_check_funcs == NULL) {
	   // only add one callback, actual callback list is kept in Python
	   Fl::add_check(pyFLTK_checkCallback);
	 }
	 // add tye python callback
	 check_link *cb = new check_link;
	 cb->next = py_check_funcs;
	 cb->handle = func;
	 cb->args = data;
	 py_check_funcs = cb;
	 Py_INCREF(func);
	 Py_XINCREF(data);
       }

     Py_INCREF(Py_None);
     return Py_None;
   }

PyObject * Fl_remove_check(PyObject *self, PyObject *args) 
   {
     PyObject *func = 0;
     PyObject *data = 0;
     PyArg_ParseTuple( args, "O|0", &func, &data);

     if (py_check_funcs != NULL) {
       check_link *l, *p;

       // Search for the handler in the list...
       for (l = py_check_funcs, p = 0; l && l->handle != func; p = l, l = l->next);

       if (l) {
	 // Found it, so remove it from the list...
	 if (p) 
	   p->next = l->next;
	 else 
	   py_check_funcs = l->next;

	 // reference count
	 Py_DECREF(l->handle);
	 Py_XDECREF(l->args);

	 // And free the record...
	 delete l;
       }
       // was this the last one?
       if (py_check_funcs == NULL) {
	 // remove the fltk handler to avoid memory leaks
	 Fl::remove_check(pyFLTK_checkCallback);
       }
     }
     Py_INCREF(Py_None);
     return Py_None;
   }




 



 
	
PyObject *Fl_get_font_sizes_tmp(PyObject *self, PyObject *args) 
{
  int fontName; 
  
  PyArg_ParseTuple( args, "i", &fontName);

  int *fontSizes = NULL;
  int size = Fl::get_font_sizes(fontName, fontSizes);

  PyObject *result = PyList_New(size);
  for (int i = 0; i < size; i++) {
    PyObject *o = PyLong_FromLong(fontSizes[i]);
    PyList_SetItem(result,i,o);
  }

  Py_INCREF(result);
  return result;
}
 

#include "FL/filename.H"


SWIGINTERN int
SWIG_AsPtr_std_string (PyObject * obj, std::string **val) 
{
  char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
  if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
    if (buf) {
      if (val) *val = new std::string(buf, size - 1);
      if (alloc == SWIG_NEWOBJ) delete[] buf;
      return SWIG_NEWOBJ;
    } else {
      if (val) *val = 0;
      return SWIG_OLDOBJ;
    }
  } else {
    PyErr_Clear();
    static swig_type_info *descriptor = SWIG_TypeQuery("std::string" " *");
    if (descriptor) {
      std::string *vptr;
      int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
      if (SWIG_IsOK(res) && val) *val = vptr;
      return res;
    }
  }
  return SWIG_ERROR;
}


SWIGINTERNINLINE PyObject *
SWIG_From_std_string  (const std::string& s)
{
  return SWIG_FromCharPtrAndSize(s.data(), s.size());
}


#include "FL/Fl_Valuator.H"

SWIGINTERN void Fl_Valuator_init_type(Fl_Valuator *self,char *Fl_Valuator){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Valuator, strlen(Fl_Valuator));
    self->user_data(cb);
  }

#include "FL/Fl_Adjuster.H"

SWIGINTERN void Fl_Adjuster_init_type(Fl_Adjuster *self,char *Fl_Adjuster){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Adjuster, strlen(Fl_Adjuster));
    self->user_data(cb);
  }

#include "FL/fl_ask.H"


  const char *fl_vararg_input(const char *label, const char *deflt = 0) {
    const char* result = 0;
    result = fl_input("%s", deflt, label);
    return result;
  };

  const char *fl_vararg_password(const char *label, const char *deflt = 0) {
    const char* result = 0;
    result = fl_password("%s", deflt, label);
    return result;
  };

  const char* fl_no_get() {
    return fl_yes;
  };
  const char* fl_yes_get() {
    return fl_yes;
  };
 const char* fl_ok_get() {
    return fl_yes;
 };
 const char* fl_cancel_get() {
    return fl_yes;
 };
 const char* fl_close_get() {
    return fl_yes;
 };
 void fl_no_set(const char* value) {
   fl_no = value;
 };
 void fl_yes_set(const char* value) {
   fl_yes = value;
 };
 void fl_ok_set(const char* value) {
   fl_ok = value;
 };
 void fl_cancel_set(const char* value) {
   fl_cancel = value;
 };
 void fl_close_set(const char* value) {
   fl_close = value;
 };


  void fl_mt_message(const char* text) {
    Py_BEGIN_ALLOW_THREADS;
    fl_message("%s", text);
    Py_END_ALLOW_THREADS;
  };

  void fl_mt_alert(const char* text) {
    Py_BEGIN_ALLOW_THREADS;
    fl_alert("%s", text);
    Py_END_ALLOW_THREADS;
  };

  
  // int fl_mt_ask(const char* text) {
  //   int status = 0;
  //   #ifdef __GNUC__
  //   #pragma GCC diagnostic push
  //   #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  //   #endif
  //   Py_BEGIN_ALLOW_THREADS;
  //   status = fl_ask("%s", text);
  //   Py_END_ALLOW_THREADS;
  //   #ifdef __GNUC__
  //   #pragma GCC diagnostic pop
  //   #endif
  //   return status;
  // };

  int fl_mt_choice(const char *q,const char *b0,const char *b1,const char *b2) {
    int status = 0;
    Py_BEGIN_ALLOW_THREADS;
    status = fl_choice("%s", b0, b1, b2, q);
    Py_END_ALLOW_THREADS;
    return status;
  };

  const char *fl_mt_input(const char *label, const char *deflt = 0) {
    const char* result = 0;
    Py_BEGIN_ALLOW_THREADS;
    result = fl_input("%s", deflt, label);
    Py_END_ALLOW_THREADS;
    return result;
  };

  const char *fl_mt_password(const char *label, const char *deflt = 0) {
    const char* result = 0;
    Py_BEGIN_ALLOW_THREADS;
    result = fl_password("%s", deflt, label);
    Py_END_ALLOW_THREADS;
    return result;
  };



#include "FL/Fl_Bitmap.H"


#include "FL/Fl_BMP_Image.H"


#include "FL/Fl_Box.H"
  
SWIGINTERN void Fl_Box_init_type(Fl_Box *self,char *Fl_Box){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Box, strlen(Fl_Box));
    self->user_data(cb);
  }

#include "FL/Fl_Button.H"

SWIGINTERN void Fl_Button_init_type(Fl_Button *self,char *Fl_Button){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Button, strlen(Fl_Button));
    self->user_data(cb);
  }

#include "FL/Fl_Shortcut_Button.H"

SWIGINTERN void Fl_Shortcut_Button_init_type(Fl_Shortcut_Button *self,char *Fl_Shortcut_Button){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Shortcut_Button, strlen(Fl_Shortcut_Button));
    self->user_data(cb);
  }

#include "FL/Fl_Chart.H"

SWIGINTERN void Fl_Chart_init_type(Fl_Chart *self,char *Fl_Chart){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Chart, strlen(Fl_Chart));
    self->user_data(cb);
  }

#include "FL/Fl_Check_Browser.H"

SWIGINTERN void Fl_Check_Browser_init_type(Fl_Check_Browser *self,char *Fl_Check_Browser){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Check_Browser, strlen(Fl_Check_Browser));
    self->user_data(cb);
  }

#include "FL/Fl_Light_Button.H"

SWIGINTERN void Fl_Light_Button_init_type(Fl_Light_Button *self,char *Fl_Light_Button){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Light_Button, strlen(Fl_Light_Button));
    self->user_data(cb);
  }

#include "FL/Fl_Check_Button.H"

SWIGINTERN void Fl_Check_Button_init_type(Fl_Check_Button *self,char *Fl_Check_Button){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Check_Button, strlen(Fl_Check_Button));
    self->user_data(cb);
  }

#include "FL/Fl_Menu_.H"
#include <menu_item.h>


#include "CallbackStruct.h"
#include <FL/Fl_Button.H>

  //static PyObject *my_pycallback = NULL;
  static void Fl_Menu__PythonCallBack(Fl_Menu_ *widget, void *clientdata)
    {
      PyObject *func, *arglist;
      PyObject *result;
      PyObject *obj = 0;
      CallbackStruct* cb = (CallbackStruct*)clientdata;

      // This is the function .... 
      func = cb->func;

      if (cb->widget != 0) {
        // the parent widget
        obj = (PyObject *)( ((CallbackStruct *)clientdata)->widget);
      }
      else if (cb->type != 0) {
        // this is the type of widget
        swig_type_info *descr = (swig_type_info *)cb->type;
        if (descr != 0) {
          //printf("success\n");
          obj = SWIG_NewPointerObj(widget, (swig_type_info *)descr, 0);
        }
      }
      if (obj == 0) {
        // generic fallback
        obj = SWIG_NewPointerObj(widget, SWIGTYPE_p_Fl_Menu_, 0);
      }

      if (((CallbackStruct *)clientdata)->data)
	{
	  arglist = Py_BuildValue("(OO)", obj, (PyObject *)(((CallbackStruct *)clientdata)->data) ); 
	}
      else
	{
	  arglist = Py_BuildValue("(O)", obj ); 
	}

      result =  PyObject_CallObject(func, arglist);
   
      //Py_XDECREF(arglist);                           // Trash arglist
      Py_XDECREF(result);
      PyObject *error = PyErr_Occurred();
      {
	if (error != NULL) {
	  throw Swig::DirectorMethodException();
	}
      }
      //if (PyErr_Occurred())
      //{
      //  PyErr_Print();
      //}
   
      return /*void*/;
    }
  
SWIGINTERN void Fl_Menu__init_type(Fl_Menu_ *self,char *Fl_Menu_){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Menu_, strlen(Fl_Menu_));
    self->user_data(cb);
  }
SWIGINTERN void Fl_Menu__copy__SWIG_1(Fl_Menu_ *self,PyObject *args,PyObject *user_data=0){
		PyObject *menuList;
		if (!PyTuple_Check(args))
		{
			printf("Fl_Menu_.menu: not a tuple\n");
			return;
		}

		menuList = args;
		Fl_Menu_Item *theMenuItems = createFl_Menu_Item_Array( NULL, menuList);

		// call the C++ object to add the menu
		self->copy(theMenuItems, user_data);

		delete [] theMenuItems;

	}
SWIGINTERN void Fl_Menu__menu__SWIG_1(Fl_Menu_ *self,PyObject *args){
		PyObject *menuList;
		if (!PyTuple_Check(args))
		{
			printf("Fl_Menu_.menu: not a tuple\n");
			return;
		}

		menuList = args;
		Fl_Menu_Item *theMenuItems = createFl_Menu_Item_Array( NULL, menuList);

		// call the C++ object to add the menu
		self->copy(theMenuItems);

		delete [] theMenuItems;

	}
SWIGINTERN int Fl_Menu__add__SWIG_2(Fl_Menu_ *self,PyObject *lObj,PyObject *sObj,PyObject *cObj,PyObject *uObj=0,PyObject *fObj=0){

		//char *pyLabel=PyString_AsString(lObj);
		//char* pyLabel = SWIG_Python_str_AsChar(lObj);
                const char* pyLabel = PyUnicode_AsUTF8(lObj);

		int shortcut=PyInt_AsLong(sObj);
		PyObject *callback=cObj;
		PyObject *userData=uObj;
		int flags=0;
		if (fObj)
		   flags=PyInt_AsLong(fObj);
		Fl_Callback *callback_=(Fl_Callback*)0;
		void *user_data_=0;
		

		// got all the values
		if (callback && PyCallable_Check(callback))
		{
			CallbackStruct *cb = new CallbackStruct( callback, userData, SWIGTYPE_p_Fl_Menu_Item  );
			Py_INCREF(callback);
			//self->callback(PythonCallBack, (void *)cb);
			callback_ = (Fl_Callback *)Fl_Menu__PythonCallBack;
			user_data_ = (void *)cb;
		}

		return self->add(pyLabel, shortcut, callback_, user_data_, flags);
	}
SWIGINTERN PyObject *Fl_Menu__menu__SWIG_2(Fl_Menu_ *self){
	    // returns the Fl_Menu_Item structure of the menu
	    // as a Python list
	    const Fl_Menu_Item* items = self->menu();
	    int length = self->size();
	    PyObject *result = PyList_New(length);
	    for (int i = 0; i < length; i++) {
		PyObject *o = Py_None;
		if (items[i].text != NULL) {
		    if (items[i].callback_) {
			// registered callback, 
			// caution, callback information is in user_data
			CallbackStruct *cb = (CallbackStruct*)items[i].user_data_;
			o = Py_BuildValue("zlOOl", items[i].text, items[i].shortcut_, cb->func, cb->data, items[i].flags);
		    }
		    else {
			// no callback, return Py_None
			o = Py_BuildValue("zlOOl", items[i].text, items[i].shortcut_, Py_None, Py_None, items[i].flags);
		    }
		}
		else {
		    // empty item
		    o = Py_BuildValue("OOOOO", Py_None, Py_None, Py_None, Py_None, Py_None);
		}
		PyList_SetItem(result, i, o);
	    }
	    return result;
	}

#include "FL/Fl_Menu.H"


#include "FL/Fl_Choice.H"

SWIGINTERN void Fl_Choice_init_type(Fl_Choice *self,char *Fl_Choice){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Choice, strlen(Fl_Choice));
    self->user_data(cb);
  }

#include "FL/Fl_Copy_Surface.H"


#include "FL/Fl_Clock.H"

SWIGINTERN void Fl_Clock_Output_init_type(Fl_Clock_Output *self,char *Fl_Clock_Output){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Clock_Output, strlen(Fl_Clock_Output));
    self->user_data(cb);
  }
SWIGINTERN void Fl_Clock_init_type(Fl_Clock *self,char *Fl_Clock){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Clock, strlen(Fl_Clock));
    self->user_data(cb);
  }

#include "FL/Fl_Value_Input.H"

SWIGINTERN void Fl_Value_Input_init_type(Fl_Value_Input *self,char *Fl_Value_Input){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Value_Input, strlen(Fl_Value_Input));
    self->user_data(cb);
  }

#include "FL/Fl_Color_Chooser.H"

SWIGINTERN void Flcc_HueBox_init_type(Flcc_HueBox *self,char *Flcc_HueBox){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Flcc_HueBox, strlen(Flcc_HueBox));
    self->user_data(cb);
  }
SWIGINTERN void Flcc_ValueBox_init_type(Flcc_ValueBox *self,char *Flcc_ValueBox){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Flcc_ValueBox, strlen(Flcc_ValueBox));
    self->user_data(cb);
  }
SWIGINTERN void Flcc_Value_Input_init_type(Flcc_Value_Input *self,char *Flcc_Value_Input){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Flcc_Value_Input, strlen(Flcc_Value_Input));
    self->user_data(cb);
  }
SWIGINTERN void Fl_Color_Chooser_init_type(Fl_Color_Chooser *self,char *Fl_Color_Chooser){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Color_Chooser, strlen(Fl_Color_Chooser));
    self->user_data(cb);
  }

#include "FL/Fl_Counter.H"

SWIGINTERN void Fl_Counter_init_type(Fl_Counter *self,char *Fl_Counter){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Counter, strlen(Fl_Counter));
    self->user_data(cb);
  }

#include "FL/Fl_Plugin.H"


#include "FL/Fl_Device.H"


#include "FL/Fl_Dial.H"


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

SWIGINTERN void Fl_Dial_init_type(Fl_Dial *self,char *Fl_Dial){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Dial, strlen(Fl_Dial));
    self->user_data(cb);
  }

#include "FL/Fl_Window.H"

SWIGINTERN void Fl_Window_init_type(Fl_Window *self,char *Fl_Window){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Window, strlen(Fl_Window));
    self->user_data(cb);
  }
SWIGINTERN void Fl_Window_show(Fl_Window *self,PyObject *count=0,PyObject *data=0){
  Py_XINCREF(count);
  Py_XINCREF(data);
  if (!count)
    self->show();
  else if (!data) {
    if (PyList_Check(count)) {
      Py_ssize_t size = PyList_Size(count);
      int i = 0;
      char** tmp = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
          PyObject *o = PyList_GetItem(count,i);
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
          //tmp[i] = SWIG_Python_str_AsChar(PyList_GetItem(count,i));
     tmp[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(count,i)));
	  //tmp[i] = PyString_AsString(PyList_GetItem(count,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show();
      free(tmp);
    }
  }
  else {
    if (PyList_Check(data)) {
      int size = PyInt_AsLong(count);
      int i = 0;
      char** tmp = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
	PyObject *o = PyList_GetItem(data,i);
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
          //tmp[i] = SWIG_Python_str_AsChar(PyList_GetItem(data,i));
     tmp[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(data,i)));
	  //tmp[i] = PyString_AsString(PyList_GetItem(data,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show();
      free(tmp);
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      self->show();
    }
		
  }
}

#include "FL/Fl_Double_Window.H"

SWIGINTERN void Fl_Double_Window_init_type(Fl_Double_Window *self,char *Fl_Double_Window){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Double_Window, strlen(Fl_Double_Window));
    self->user_data(cb);
  }
SWIGINTERN void Fl_Double_Window_show(Fl_Double_Window *self,PyObject *count=0,PyObject *data=0){
  Py_XINCREF(count);
  Py_XINCREF(data);
  if (!count)
    self->show();
  else if (!data) {
    if (PyList_Check(count)) {
      Py_ssize_t size = PyList_Size(count);
      int i = 0;
      char** tmp = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
          PyObject *o = PyList_GetItem(count,i);
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
          //tmp[i] = SWIG_Python_str_AsChar(PyList_GetItem(count,i));
     tmp[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(count,i)));
	  //tmp[i] = PyString_AsString(PyList_GetItem(count,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show();
      free(tmp);
    }
  }
  else {
    if (PyList_Check(data)) {
      int size = PyInt_AsLong(count);
      int i = 0;
      char** tmp = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
	PyObject *o = PyList_GetItem(data,i);
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
          //tmp[i] = SWIG_Python_str_AsChar(PyList_GetItem(data,i));
     tmp[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(data,i)));
	  //tmp[i] = PyString_AsString(PyList_GetItem(data,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show();
      free(tmp);
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      self->show();
    }
		
  }
}

#include "FL/fl_draw.H"


#include "FL/Fl_Input_.H"

SWIGINTERN void Fl_Input__init_type(Fl_Input_ *self,char *Fl_Input_){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Input_, strlen(Fl_Input_));
    self->user_data(cb);
  }

#include "FL/Fl_Input.H"

SWIGINTERN void Fl_Input_init_type(Fl_Input *self,char *Fl_Input){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Input, strlen(Fl_Input));
    self->user_data(cb);
  }

#include "FL/Fl_File_Input.H"

SWIGINTERN void Fl_File_Input_init_type(Fl_File_Input *self,char *Fl_File_Input){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_File_Input, strlen(Fl_File_Input));
    self->user_data(cb);
  }

#include "FL/Fl_Fill_Dial.H"

SWIGINTERN void Fl_Fill_Dial_init_type(Fl_Fill_Dial *self,char *Fl_Fill_Dial){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Fill_Dial, strlen(Fl_Fill_Dial));
    self->user_data(cb);
  }

#include "FL/Fl_Slider.H"

SWIGINTERN void Fl_Slider_init_type(Fl_Slider *self,char *Fl_Slider){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Slider, strlen(Fl_Slider));
    self->user_data(cb);
  }

#include "FL/Fl_Fill_Slider.H"

SWIGINTERN void Fl_Fill_Slider_init_type(Fl_Fill_Slider *self,char *Fl_Fill_Slider){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Fill_Slider, strlen(Fl_Fill_Slider));
    self->user_data(cb);
  }

#include "FL/Fl_Flex.H"

SWIGINTERN void Fl_Flex_init_type(Fl_Flex *self,char *Fl_Flex){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Flex, strlen(Fl_Flex));
    self->user_data(cb);
  }

#include "FL/Fl_Float_Input.H"

SWIGINTERN void Fl_Float_Input_init_type(Fl_Float_Input *self,char *Fl_Float_Input){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Float_Input, strlen(Fl_Float_Input));
    self->user_data(cb);
  }

#include "FL/Fl_Pixmap.H"


#include "FL/Fl_Grid.H"


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 = (unsigned short)(v);
    }
  }  
  return res;
}

SWIGINTERN void Fl_Grid_init_type(Fl_Grid *self,char *Fl_Grid){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Grid, strlen(Fl_Grid));
    self->user_data(cb);
  }

#include "FL/Fl_GIF_Image.H"


#include "FL/Fl_Anim_GIF_Image.H"


#include "FL/Fl_ICO_Image.H"


#include "FL/Fl_Image_Surface.H"


#include "FL/fl_string_functions.h"


#include "FL/Fl_Gl_Window.H"
#include "FL/gl.h"
#include "string.h"

SWIGINTERN void Fl_Gl_Window_init_type(Fl_Gl_Window *self,char *Fl_Gl_Window){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Gl_Window, strlen(Fl_Gl_Window));
    self->user_data(cb);
  }
SWIGINTERN void Fl_Gl_Window_show(Fl_Gl_Window *self,PyObject *count=0,PyObject *data=0){
  Py_XINCREF(count);
  Py_XINCREF(data);
  if (!count)
    self->show();
  else if (!data) {
    if (PyList_Check(count)) {
      Py_ssize_t size = PyList_Size(count);
      int i = 0;
      char** tmp = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
          PyObject *o = PyList_GetItem(count,i);
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
          //tmp[i] = SWIG_Python_str_AsChar(PyList_GetItem(count,i));
     tmp[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(count,i)));
	  //tmp[i] = PyString_AsString(PyList_GetItem(count,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show();
      free(tmp);
    }
  }
  else {
    if (PyList_Check(data)) {
      int size = PyInt_AsLong(count);
      int i = 0;
      char** tmp = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
	PyObject *o = PyList_GetItem(data,i);
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
          //tmp[i] = SWIG_Python_str_AsChar(PyList_GetItem(data,i));
     tmp[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(data,i)));
	  //tmp[i] = PyString_AsString(PyList_GetItem(data,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show();
      free(tmp);
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      self->show();
    }
		
  }
}
SWIGINTERN void Fl_Gl_Window_drawPixels(Fl_Gl_Window *self,PyObject *rgb_py){

    char *rgb;
    size_t len; 
    int i, height=self->h(), halfheight=self->h()/2, rowsize=self->w()*3;
    char *row0, *row1;

    char *tmp = new char [rowsize];
    SWIG_AsCharPtrAndSize(rgb_py, &rgb, &len, 0);

    row0 = rgb;
    row1 = rgb + (height-1) * rowsize;
    for (i=0; i<halfheight; i++) {
        memcpy(tmp, row0, rowsize);
        memcpy(row0, row1, rowsize);
        memcpy(row1, tmp, rowsize);
        row0 += rowsize;
        row1 -= rowsize;
    }

    glDrawPixels(self->w(), self->h(), GL_RGB, GL_UNSIGNED_BYTE, rgb);

    delete [] tmp;
}

#include "FL/Fl_Help_Dialog.H"


#include "FL/Fl_Help_View.H"


#include "CallbackStruct.h"
#include <FL/Fl_Button.H>

  //static PyObject *my_pycallback = NULL;

  static const char* PythonLink(Fl_Widget *widget, const char *uri)
    {
      PyObject *func, *arglist;
      PyObject *result;
      PyObject *obj;

      CallbackStruct *cb = (CallbackStruct *)(widget->user_data());

      if (cb == NULL)
	return NULL;

      // This is the function .... 
      func = (PyObject *)( cb->link);
      if (func == NULL) {
	PyErr_SetString(PyExc_NotImplementedError, "Callable link not found!");
	return NULL;
      }

      // always of the same type: Fl_Help_View
      //obj = SWIG_NewPointerObj(widget, SWIGTYPE_p_Fl_Help_View, 0);
      // the parent widget
      obj = (PyObject *)( cb->widget);

      // build arument list
      arglist = Py_BuildValue("(Os)", obj, uri ); 

      // call the callback
      result =  PyObject_CallObject(func, arglist);

   
      Py_DECREF(arglist);                           // Trash arglist
      Py_XDECREF(result);
      if (PyErr_Occurred())
	{
	  PyErr_Print();
	}
#ifndef PYTHON3   
      if (result == Py_None)
	return NULL;
      else
	return PyString_AsString(result); /*void*/;
#else
     return NULL;
#endif
    }
  
SWIGINTERN void Fl_Help_View_init_type(Fl_Help_View *self,char *Fl_Help_View){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Help_View, strlen(Fl_Help_View));
    self->user_data(cb);
  }
SWIGINTERN void Fl_Help_View_link__SWIG_1(Fl_Help_View *self,PyObject *PyFunc,PyObject *PyWidget){
      // get existing callback structure
      CallbackStruct *cb = (CallbackStruct*)self->user_data();

      // use the link member to hold the callback
      if (cb) {
	cb->link = PyFunc;
      }
      else {
	cb = new CallbackStruct( 0, 0, PyWidget, PyFunc );
	self->user_data((void*)cb);
      }

      // Add a reference to new callback
      Py_INCREF(PyFunc);			
      Py_XINCREF(PyWidget);	
	
      self->link(&PythonLink);
      
    
    }

#include "FL/Fl_Hold_Browser.H"

SWIGINTERN void Fl_Hold_Browser_init_type(Fl_Hold_Browser *self,char *Fl_Hold_Browser){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Hold_Browser, strlen(Fl_Hold_Browser));
    self->user_data(cb);
  }

#include "FL/Fl_Hor_Fill_Slider.H"

SWIGINTERN void Fl_Hor_Fill_Slider_init_type(Fl_Hor_Fill_Slider *self,char *Fl_Hor_Fill_Slider){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Hor_Fill_Slider, strlen(Fl_Hor_Fill_Slider));
    self->user_data(cb);
  }

#include "FL/Fl_Hor_Nice_Slider.H"

SWIGINTERN void Fl_Hor_Nice_Slider_init_type(Fl_Hor_Nice_Slider *self,char *Fl_Hor_Nice_Slider){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Hor_Nice_Slider, strlen(Fl_Hor_Nice_Slider));
    self->user_data(cb);
  }

#include "FL/Fl_Hor_Slider.H"

SWIGINTERN void Fl_Hor_Slider_init_type(Fl_Hor_Slider *self,char *Fl_Hor_Slider){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Hor_Slider, strlen(Fl_Hor_Slider));
    self->user_data(cb);
  }

#include "FL/Fl_Value_Slider.H"

SWIGINTERN void Fl_Value_Slider_init_type(Fl_Value_Slider *self,char *Fl_Value_Slider){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Value_Slider, strlen(Fl_Value_Slider));
    self->user_data(cb);
  }

#include "FL/Fl_Hor_Value_Slider.H"

SWIGINTERN void Fl_Hor_Value_Slider_init_type(Fl_Hor_Value_Slider *self,char *Fl_Hor_Value_Slider){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Hor_Value_Slider, strlen(Fl_Hor_Value_Slider));
    self->user_data(cb);
  }

#include "FL/Fl_Int_Input.H"

SWIGINTERN void Fl_Int_Input_init_type(Fl_Int_Input *self,char *Fl_Int_Input){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Int_Input, strlen(Fl_Int_Input));
    self->user_data(cb);
  }

#include "FL/Fl_Input_Choice.H"

SWIGINTERN void Fl_Input_Choice_init_type(Fl_Input_Choice *self,char *Fl_Input_Choice){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Input_Choice, strlen(Fl_Input_Choice));
    self->user_data(cb);
  }

#include "FL/Fl_JPEG_Image.H"


#include "FL/Fl_Line_Dial.H"

SWIGINTERN void Fl_Line_Dial_init_type(Fl_Line_Dial *self,char *Fl_Line_Dial){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Line_Dial, strlen(Fl_Line_Dial));
    self->user_data(cb);
  }

#include "FL/Fl_Menu_Bar.H"

SWIGINTERN void Fl_Menu_Bar_init_type(Fl_Menu_Bar *self,char *Fl_Menu_Bar){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Menu_Bar, strlen(Fl_Menu_Bar));
    self->user_data(cb);
  }

#include "FL/Fl_Menu_Button.H"

SWIGINTERN void Fl_Menu_Button_init_type(Fl_Menu_Button *self,char *Fl_Menu_Button){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Menu_Button, strlen(Fl_Menu_Button));
    self->user_data(cb);
  }

#include "FL/Fl_Menu_Item.H"
#include <CallbackStruct.h>
#include "FL/Fl_Multi_Label.H"

SWIGINTERN PyObject *Fl_Menu_Item_callback__SWIG_4(Fl_Menu_Item *self){
	CallbackStruct *cb = (CallbackStruct*)self->user_data_;
	PyObject *o = Py_BuildValue("O", cb->func);
	return o;
    }
SWIGINTERN PyObject *Fl_Menu_Item_user_data(Fl_Menu_Item *self){
	CallbackStruct *cb = (CallbackStruct*)self->user_data_;
	PyObject *o = Py_BuildValue("O", cb->data);
	return o;
    }
SWIGINTERN void Fl_Menu_Item_add_multi_label(Fl_Menu_Item *self,Fl_Pixmap *pixmap){
      //save label text as self->image below clobbers it
      const char* itemtext= self->label();
      
      //Assign image to menu item
      self->image(*pixmap); //clobbers self->label()
      Fl_Multi_Label *ml = new Fl_Multi_Label();

      ml->typea = _FL_IMAGE_LABEL;
      ml->labela = (const char*)pixmap;
      ml->typeb = FL_NORMAL_LABEL;
      ml->labelb = itemtext;

      ml->label(self);
    }

#include "FL/Fl_Single_Window.H"

SWIGINTERN void Fl_Single_Window_init_type(Fl_Single_Window *self,char *Fl_Single_Window){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Single_Window, strlen(Fl_Single_Window));
    self->user_data(cb);
  }
SWIGINTERN void Fl_Single_Window_show(Fl_Single_Window *self,PyObject *count=0,PyObject *data=0){
  Py_XINCREF(count);
  Py_XINCREF(data);
  if (!count)
    self->show();
  else if (!data) {
    if (PyList_Check(count)) {
      Py_ssize_t size = PyList_Size(count);
      int i = 0;
      char** tmp = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
          PyObject *o = PyList_GetItem(count,i);
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
          //tmp[i] = SWIG_Python_str_AsChar(PyList_GetItem(count,i));
     tmp[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(count,i)));
	  //tmp[i] = PyString_AsString(PyList_GetItem(count,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show();
      free(tmp);
    }
  }
  else {
    if (PyList_Check(data)) {
      int size = PyInt_AsLong(count);
      int i = 0;
      char** tmp = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
	PyObject *o = PyList_GetItem(data,i);
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
          //tmp[i] = SWIG_Python_str_AsChar(PyList_GetItem(data,i));
     tmp[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(data,i)));
	  //tmp[i] = PyString_AsString(PyList_GetItem(data,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show();
      free(tmp);
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      self->show();
    }
		
  }
}

#include "FL/Fl_Menu_Window.H"

SWIGINTERN void Fl_Menu_Window_init_type(Fl_Menu_Window *self,char *Fl_Menu_Window){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Menu_Window, strlen(Fl_Menu_Window));
    self->user_data(cb);
  }

#include "FL/fl_message.H"


#include "FL/Fl_Multiline_Input.H"

SWIGINTERN void Fl_Multiline_Input_init_type(Fl_Multiline_Input *self,char *Fl_Multiline_Input){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Multiline_Input, strlen(Fl_Multiline_Input));
    self->user_data(cb);
  }

#include "FL/Fl_Output.H"

SWIGINTERN void Fl_Output_init_type(Fl_Output *self,char *Fl_Output){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Output, strlen(Fl_Output));
    self->user_data(cb);
  }

#include "FL/Fl_Multiline_Output.H"

SWIGINTERN void Fl_Multiline_Output_init_type(Fl_Multiline_Output *self,char *Fl_Multiline_Output){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Multiline_Output, strlen(Fl_Multiline_Output));
    self->user_data(cb);
  }

#include "FL/Fl_Multi_Browser.H"

SWIGINTERN void Fl_Multi_Browser_init_type(Fl_Multi_Browser *self,char *Fl_Multi_Browser){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Multi_Browser, strlen(Fl_Multi_Browser));
    self->user_data(cb);
  }

#include "FL/Fl_Multi_Label.H"


#include "FL/Fl_Nice_Slider.H"

SWIGINTERN void Fl_Nice_Slider_init_type(Fl_Nice_Slider *self,char *Fl_Nice_Slider){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Nice_Slider, strlen(Fl_Nice_Slider));
    self->user_data(cb);
  }

#include "FL/Fl_Native_File_Chooser.H"


#include "FL/Fl_Overlay_Window.H"

SWIGINTERN void Fl_Overlay_Window_init_type(Fl_Overlay_Window *self,char *Fl_Overlay_Window){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Overlay_Window, strlen(Fl_Overlay_Window));
    self->user_data(cb);
  }
SWIGINTERN void Fl_Overlay_Window_show(Fl_Overlay_Window *self,PyObject *count=0,PyObject *data=0){
  Py_XINCREF(count);
  Py_XINCREF(data);
  if (!count)
    self->show();
  else if (!data) {
    if (PyList_Check(count)) {
      Py_ssize_t size = PyList_Size(count);
      int i = 0;
      char** tmp = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
          PyObject *o = PyList_GetItem(count,i);
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
          //tmp[i] = SWIG_Python_str_AsChar(PyList_GetItem(count,i));
     tmp[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(count,i)));
	  //tmp[i] = PyString_AsString(PyList_GetItem(count,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show();
      free(tmp);
    }
  }
  else {
    if (PyList_Check(data)) {
      int size = PyInt_AsLong(count);
      int i = 0;
      char** tmp = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
	PyObject *o = PyList_GetItem(data,i);
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
          //tmp[i] = SWIG_Python_str_AsChar(PyList_GetItem(data,i));
     tmp[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(data,i)));
	  //tmp[i] = PyString_AsString(PyList_GetItem(data,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show();
      free(tmp);
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      self->show();
    }
		
  }
}

#include "FL/Fl_Pack.H"

SWIGINTERN void Fl_Pack_init_type(Fl_Pack *self,char *Fl_Pack){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Pack, strlen(Fl_Pack));
    self->user_data(cb);
  }

#include "FL/Fl_PNG_Image.H"


#include "FL/Fl_PNM_Image.H"


#include "FL/Fl_Positioner.H"

SWIGINTERN void Fl_Positioner_init_type(Fl_Positioner *self,char *Fl_Positioner){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Positioner, strlen(Fl_Positioner));
    self->user_data(cb);
  }

#include "FL/Fl_Preferences.H"


#include "FL/Fl_Progress.H"

SWIGINTERN void Fl_Progress_init_type(Fl_Progress *self,char *Fl_Progress){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Progress, strlen(Fl_Progress));
    self->user_data(cb);
  }

#include "FL/Fl_Radio_Button.H"

SWIGINTERN void Fl_Radio_Button_init_type(Fl_Radio_Button *self,char *Fl_Radio_Button){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Radio_Button, strlen(Fl_Radio_Button));
    self->user_data(cb);
  }

#include "FL/Fl_Radio_Light_Button.H"

SWIGINTERN void Fl_Radio_Light_Button_init_type(Fl_Radio_Light_Button *self,char *Fl_Radio_Light_Button){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Radio_Light_Button, strlen(Fl_Radio_Light_Button));
    self->user_data(cb);
  }

#include "FL/Fl_Round_Button.H"

SWIGINTERN void Fl_Round_Button_init_type(Fl_Round_Button *self,char *Fl_Round_Button){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Round_Button, strlen(Fl_Round_Button));
    self->user_data(cb);
  }

#include "FL/Fl_Radio_Round_Button.H"

SWIGINTERN void Fl_Radio_Round_Button_init_type(Fl_Radio_Round_Button *self,char *Fl_Radio_Round_Button){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Radio_Round_Button, strlen(Fl_Radio_Round_Button));
    self->user_data(cb);
  }

#include "FL/Fl_Repeat_Button.H"

SWIGINTERN void Fl_Repeat_Button_init_type(Fl_Repeat_Button *self,char *Fl_Repeat_Button){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Repeat_Button, strlen(Fl_Repeat_Button));
    self->user_data(cb);
  }

#include "FL/Fl_Return_Button.H"

SWIGINTERN void Fl_Return_Button_init_type(Fl_Return_Button *self,char *Fl_Return_Button){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Return_Button, strlen(Fl_Return_Button));
    self->user_data(cb);
  }

#include "FL/Fl_Rect.H"


#include "FL/Fl_RGB_Image.H"


#include "FL/Fl_SVG_Image.H"


#include "FL/Fl_SVG_File_Surface.H"


#include "FL/Fl_Roller.H"

SWIGINTERN void Fl_Roller_init_type(Fl_Roller *self,char *Fl_Roller){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Roller, strlen(Fl_Roller));
    self->user_data(cb);
  }

#include "FL/Fl_Round_Clock.H"

SWIGINTERN void Fl_Round_Clock_init_type(Fl_Round_Clock *self,char *Fl_Round_Clock){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Round_Clock, strlen(Fl_Round_Clock));
    self->user_data(cb);
  }

#include "FL/Fl_Scroll.H"

SWIGINTERN void Fl_Scroll_init_type(Fl_Scroll *self,char *Fl_Scroll){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Scroll, strlen(Fl_Scroll));
    self->user_data(cb);
  }
SWIGINTERN Fl_Scrollbar *Fl_Scroll_getScrollbar(Fl_Scroll *self){
		return &(self->scrollbar);
	}
SWIGINTERN Fl_Scrollbar *Fl_Scroll_getHScrollbar(Fl_Scroll *self){
		return &(self->hscrollbar);
	}

#include "FL/Fl_Scheme_Choice.H"

SWIGINTERN void Fl_Scheme_Choice_init_type(Fl_Scheme_Choice *self,char *Fl_Scheme_Choice){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Scheme_Choice, strlen(Fl_Scheme_Choice));
    self->user_data(cb);
  }

#include "FL/Fl_Scrollbar.H"

SWIGINTERN void Fl_Scrollbar_init_type(Fl_Scrollbar *self,char *Fl_Scrollbar){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Scrollbar, strlen(Fl_Scrollbar));
    self->user_data(cb);
  }

#include "FL/Fl_Secret_Input.H"

SWIGINTERN void Fl_Secret_Input_init_type(Fl_Secret_Input *self,char *Fl_Secret_Input){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Secret_Input, strlen(Fl_Secret_Input));
    self->user_data(cb);
  }

#include "FL/Fl_Select_Browser.H"

SWIGINTERN void Fl_Select_Browser_init_type(Fl_Select_Browser *self,char *Fl_Select_Browser){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Select_Browser, strlen(Fl_Select_Browser));
    self->user_data(cb);
  }

#include "FL/Fl_Shared_Image.H"


#include "FL/Fl_Spinner.H"

SWIGINTERN void Fl_Spinner_init_type(Fl_Spinner *self,char *Fl_Spinner){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Spinner, strlen(Fl_Spinner));
    self->user_data(cb);
  }
SWIGINTERN void Fl_Spinner_min__SWIG_0(Fl_Spinner *self,double m){
    self->minimum(m);
  }
SWIGINTERN double Fl_Spinner_min__SWIG_1(Fl_Spinner *self){
    return self->minimum();
  }
SWIGINTERN void Fl_Spinner_max__SWIG_0(Fl_Spinner *self,double m){
    self->maximum(m);
  }
SWIGINTERN double Fl_Spinner_max__SWIG_1(Fl_Spinner *self){
    return self->maximum();
  }

#include "FL/fl_show_colormap.H"


#include "FL/fl_show_input.H"


#include "FL/Fl_Simple_Counter.H"

SWIGINTERN void Fl_Simple_Counter_init_type(Fl_Simple_Counter *self,char *Fl_Simple_Counter){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Simple_Counter, strlen(Fl_Simple_Counter));
    self->user_data(cb);
  }

#include "FL/Fl_Sys_Menu_Bar.H"

SWIGINTERN void Fl_Sys_Menu_Bar_init_type(Fl_Sys_Menu_Bar *self,char *Fl_Sys_Menu_Bar){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Sys_Menu_Bar, strlen(Fl_Sys_Menu_Bar));
    self->user_data(cb);
  }

#include "FL/Fl_Table.H"

SWIGINTERN void Fl_Table_init_type(Fl_Table *self,char *Fl_Table){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Table, strlen(Fl_Table));
    self->user_data(cb);
  }

#include "FL/Fl_Table_Row.H"

SWIGINTERN void Fl_Table_Row_init_type(Fl_Table_Row *self,char *Fl_Table_Row){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Table_Row, strlen(Fl_Table_Row));
    self->user_data(cb);
  }

#include "FL/Fl_Tabs.H"

SWIGINTERN void Fl_Tabs_init_type(Fl_Tabs *self,char *Fl_Tabs){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Tabs, strlen(Fl_Tabs));
    self->user_data(cb);
  }

#include "FL/Fl_Terminal.H"

SWIGINTERN void Fl_Terminal_init_type(Fl_Terminal *self,char *Fl_Terminal){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Terminal, strlen(Fl_Terminal));
    self->user_data(cb);
  }

#include "FL/Fl_Text_Buffer.H"


#include "CallbackStruct.h"

struct modify_link {
  CallbackStruct *handle;
  modify_link *next;
  Fl_Text_Buffer* widget;
};

static modify_link *py_modify_funcs = NULL;

static void PythonModifyCallBack(int pos, int nInserted, int nDeleted, int nRestyled, const char* deletedText,  void* cbArg)
{
   PyObject *func, *arglist;
   PyObject *result;
   PyObject *obj;
   CallbackStruct *cb = (CallbackStruct*)cbArg;

   if (cb != NULL) {
     func = cb->func;


     // the user data
     obj = cb->data;

     if (obj == NULL) {
       arglist = Py_BuildValue("(iiiis)", pos, nInserted, nDeleted, nRestyled, deletedText );
     }
     else {
       arglist = Py_BuildValue("(iiiisO)", pos, nInserted, nDeleted, nRestyled, deletedText, obj );
     }
     result =  PyObject_CallObject(func, arglist);
     
     Py_XDECREF(arglist);                           // Trash arglist
     Py_XDECREF(result);
     if (PyErr_Occurred())
       {
	 PyErr_Print();
       }

   } 
   else
      PyErr_SetString(PyExc_TypeError, "PythonModifyCallBack: need a valid callback!");

   return;
}

SWIGINTERN void Fl_Text_Buffer_add_modify_callback__SWIG_1(Fl_Text_Buffer *self,PyObject *PyFunc,PyObject *PyTarget=0){
  if (!PyCallable_Check(PyFunc)) 
    {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
    }
  else
    {
      CallbackStruct *cb = new CallbackStruct( PyFunc, PyTarget, 0, 0 );
      self->add_modify_callback(PythonModifyCallBack, (void *)cb);


      Py_INCREF(PyFunc);    /* Add a reference to new callback */
      Py_XINCREF(PyTarget);

      // add it to global list and also add the widget!
      modify_link *cb_link = new modify_link;
      cb_link->next = py_modify_funcs;
      cb_link->handle = cb;
      cb_link->widget = self;
      py_modify_funcs = cb_link;
    }
  }
SWIGINTERN void Fl_Text_Buffer_remove_modify_callback__SWIG_1(Fl_Text_Buffer *self,PyObject *PyFunc,PyObject *PyWidget,PyObject *PyTarget){
  // Search for the handler in the list...
  modify_link *l, *p;
  for (l = py_modify_funcs, p = 0; l && !(l->handle->func == PyFunc && (0==PyObject_RichCompareBool(l->handle->data,PyTarget, Py_EQ)) && l->widget == self); p = l, l = l->next);
  if (l) {
    // Found it, so remove it from the list...
    if (p) 
      p->next = l->next;
    else 
      py_modify_funcs = l->next;

    // remove the callback
    self->remove_modify_callback(PythonModifyCallBack, (void*)l->handle);
    
    // reference count
    Py_DECREF(l->handle->func);
    Py_XDECREF(l->handle->data);
    
    // And free the record...
    delete l->handle;
    delete l;
  }

  }

#include "FL/Fl_Text_Display.H"


  static void UnfinishedStyleCB(int arg1, void *clientdata) {
    PyObject *func, *arglist;
    PyObject *result;
    
    // This is the function .... 
    func = (PyObject *)( ((CallbackStruct *)clientdata)->func);
    if (((CallbackStruct *)clientdata)->data)
      {
	arglist = Py_BuildValue("(iO)", arg1, (PyObject *)(((CallbackStruct *)clientdata)->data) ); 
      }
    else
      {
	arglist = Py_BuildValue("(iO)", arg1 ); 
      }

    result =  PyObject_CallObject(func, arglist);

    Py_DECREF(arglist);                           // Trash arglist
      Py_XDECREF(result);
      if (PyErr_Occurred())
	{
	  PyErr_Print();
	}
   
      return /*void*/;

  }


// SWIG thinks that Style_Table_Entry is a global class, so we need to trick the C++
// compiler into understanding this so called global type.
typedef Fl_Text_Display::Style_Table_Entry Style_Table_Entry;

SWIGINTERN void Fl_Text_Display_init_type(Fl_Text_Display *self,char *Fl_Text_Display){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Text_Display, strlen(Fl_Text_Display));
    self->user_data(cb);
  }
SWIGINTERN void Fl_Text_Display_highlight_data_new(Fl_Text_Display *self,Fl_Text_Buffer *styleBuffer,Fl_Text_Display::Style_Table_Entry const *styleTable,int nStyles,char unfinishedStyle,PyObject *func,PyObject *cbArg){
      if (!PyCallable_Check(func)) {
	PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      }
      else {
	CallbackStruct *cb = new CallbackStruct( func , cbArg, (PyObject*)0 );
	// add reference
	
	Py_INCREF(func);
	Py_XINCREF(cbArg);
	self->highlight_data(styleBuffer, styleTable, nStyles, unfinishedStyle, UnfinishedStyleCB, (void*)cb);
      }
      
  }

#include "FL/Fl_Text_Editor.H"

SWIGINTERN void Fl_Text_Editor_init_type(Fl_Text_Editor *self,char *Fl_Text_Editor){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Text_Editor, strlen(Fl_Text_Editor));
    self->user_data(cb);
  }

#include "FL/Fl_Tile.H"

SWIGINTERN void Fl_Tile_init_type(Fl_Tile *self,char *Fl_Tile){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Tile, strlen(Fl_Tile));
    self->user_data(cb);
  }

#include "FL/Fl_Tiled_Image.H"


#include "FL/Fl_Toggle_Button.H"

SWIGINTERN void Fl_Toggle_Button_init_type(Fl_Toggle_Button *self,char *Fl_Toggle_Button){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Toggle_Button, strlen(Fl_Toggle_Button));
    self->user_data(cb);
  }

#include "FL/Fl_Toggle_Light_Button.H"


#include "FL/Fl_Toggle_Round_Button.H"


#include "FL/Fl_Tooltip.H"


#include "FL/Fl_Value_Output.H"

SWIGINTERN void Fl_Value_Output_init_type(Fl_Value_Output *self,char *Fl_Value_Output){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Value_Output, strlen(Fl_Value_Output));
    self->user_data(cb);
  }

#include "FL/Fl_Wizard.H"

SWIGINTERN void Fl_Wizard_init_type(Fl_Wizard *self,char *Fl_Wizard){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Wizard, strlen(Fl_Wizard));
    self->user_data(cb);
  }

#include "FL/Fl_XBM_Image.H"


#include "FL/Fl_XPM_Image.H"


#include "FL/platform.H"


#include "FL/Fl_Tree_Prefs.H"


#include "FL/Fl_Tree_Item_Array.H"


#include "FL/Fl_Tree_Item.H"

SWIGINTERN void Fl_Tree_Item_init_type(Fl_Tree_Item *self,char *Fl_Tree_Item){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Tree_Item, strlen(Fl_Tree_Item));
    self->user_data(cb);
  }
SWIGINTERN void Fl_Tree_Item_user_data__SWIG_0(Fl_Tree_Item *self,PyObject *PyData){
      // Add a reference to new callback
      Py_XINCREF(PyData);
	
      CallbackStruct *cb = (CallbackStruct*)self->user_data();
      if (cb == NULL) {
	cb = new CallbackStruct(0, PyData, (PyObject*)0);
	self->user_data((void *)cb);
      }
      else {
	if (cb->data != NULL)
	  Py_XDECREF(cb->data);
	cb->data = PyData;
      }
    
    }
SWIGINTERN PyObject *Fl_Tree_Item_user_data__SWIG_1(Fl_Tree_Item *self){
    PyObject *obj = 0;
    CallbackStruct *cb = (CallbackStruct*)self->user_data();
    if (cb) {
      if (cb->data) {
	obj = (PyObject*)cb->data;

	Py_XINCREF(obj);
	return obj;
      }
    }
    // nothing found
    Py_RETURN_NONE;
  }

#include "FL/Fl_Tree.H"

SWIGINTERN void Fl_Tree_init_type(Fl_Tree *self,char *Fl_Tree){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, Fl_Tree, strlen(Fl_Tree));
    self->user_data(cb);
  }

#include "FL/Fl_Paged_Device.H"


#include "FL/Fl_PDF_File_Surface.H"


#include "FL/Fl_PostScript.H"


#include "FL/Fl_Printer.H"


#if PY_VERSION_HEX >= 0x03020000
# define SWIGPY_UNICODE_ARG(obj) ((PyObject*) (obj))
#else
# define SWIGPY_UNICODE_ARG(obj) ((PyUnicodeObject*) (obj))
#endif


#include <cwchar>


#include "FL/fl_utf8.h"


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


#include "ListSelect.h"

SWIGINTERN void ListSelect_init_type(ListSelect *self,char *ListSelect){
    CallbackStruct *cb = new CallbackStruct( 0, 0, 0, 0 );
    memcpy(cb->type_name, ListSelect, strlen(ListSelect));
    self->user_data(cb);
  }

#ifndef FL_gl_H
#define FL_gl_H

void gl_start();
void gl_finish();

void gl_color(Fl_Color);
void gl_color(int c);

void gl_rect(int x,int y,int w,int h);
void gl_rectf(int x,int y,int w,int h);

void gl_font(int fontid, int size);
int  gl_height();
int  gl_descent();
double gl_width(const char *);
double gl_width(const char *, int n);
double gl_width(uchar);

void gl_draw(const char*);
void gl_draw(const char*, int n);
void gl_draw(const char*, int x, int y);
void gl_draw(const char*, float x, float y);
void gl_draw(const char*, int n, int x, int y);
void gl_draw(const char*, int n, float x, float y);
void gl_draw(const char*, int x, int y, int w, int h, Fl_Align);
void gl_measure(const char*, int& x, int& y);

void gl_draw_image(const uchar *, int x,int y,int w,int h, int d=3, int ld=0);

//from opengl for testing
void  glLoadIdentity( void );
void  glViewport( int x, int y, int width, int height );
void  glClear( int mask );
void  glColor3f( float red, float green, float blue );
void  glBegin( int mode );
void  glEnd( void );
void  glVertex3f( float x, float y, float z );
#endif


#include "FL/math.h"



Fl_Menu_Item *createFl_Menu_Item_Array(PyObject *self, PyObject *pyMenuList)
{
	Py_ssize_t numItems = PyTuple_Size(pyMenuList);
	//if a list (mutable) and not a tuple (immutable) is passed,
	// 'numItems' == -1, so if so, assume a list and covert it to a tuple
	if (PyList_Check(pyMenuList))
	{
		//try a list
		pyMenuList = PyList_AsTuple(pyMenuList);
		numItems = PyTuple_Size(pyMenuList);
	}
	Fl_Menu_Item *arrayOfFMI = 0;
	arrayOfFMI = new Fl_Menu_Item[numItems+1];
	int index=0;
	for (; index<numItems; index++)
	{
		PyObject *nextItem = PyTuple_GetItem( pyMenuList, index );
		char *pyText=0;
		int shortcut=0;
		PyObject *callback=0;
		PyObject *userData=0;
		int flags=0;
		unsigned char labelType=0;
		unsigned char labelFont=0;
		unsigned char labelSize=0;
		unsigned char labelColor=0;
		int ok = PyArg_ParseTuple( nextItem, "z|iOOibbbb", 
			&pyText, &shortcut, &callback, &userData, &flags, 
			&labelType, &labelFont, &labelSize, &labelColor);

		Fl_Menu_Item *p = arrayOfFMI+index;
		if (ok)
		{
			//have all the components, now set the values....

			//// Yes, this is a memory leak
			//// I don't know away around it, since strings from 
			//// the scripting language are all dynamically allocated
			if ( !pyText )
			{
				p->text = 0;
			}
			else 
			{
					p->text = strdup(pyText);
			}

			p->shortcut_ = shortcut;

			if (callback && PyCallable_Check(callback))
			{
				CallbackStruct *cb = new CallbackStruct( callback, userData, SWIGTYPE_p_Fl_Menu_Item );
				Py_INCREF(callback);
				Py_XINCREF(userData);
				//self->callback(PythonCallBack, (void *)cb);
				p->callback_ = (Fl_Callback *)Fl_Menu__PythonCallBack;
				p->user_data_ = (void *)cb;
			}
			else
			{
				p->callback_ = (Fl_Callback *)0;
			}


			p->flags = flags;
			p-> labeltype_ = labelType;
			p-> labelfont_ = labelFont;
			p-> labelsize_ = labelSize;
			p-> labelcolor_ = labelColor;
		}
		else
		{
			fprintf(stderr, "Could not convert menu item %d\n", index);
			PyObject_Print(nextItem, stderr, 0);
			fprintf(stderr, "\n");
			p->text = 0;
			delete [] arrayOfFMI;
			return NULL;
		}
	}
	arrayOfFMI[index].text = 0;
	return arrayOfFMI;
}

// this is deprecated
PyObject *setMenu(PyObject *self, PyObject *args)
{
	PyObject *targetObject, *menuList;
	printf("Warning: setMenu is deprecated, use Fl_Menu_.copy() instead!\n");
	if (!PyTuple_Check(args))
	{
		printf("setMenuError: not a tup\n");
		return NULL;
	}

	if (!PyArg_ParseTuple( args, "OO", &targetObject, &menuList))
	{
		printf("no conv args\n");
		return NULL;
	}

	PyObject *thisPtrString = PyObject_GetAttrString( targetObject, "this");
#if PY_VERSION_HEX>=0x03000000
	if (!PyUnicode_Check(thisPtrString))
#else  
        if (!PyString_Check(thisPtrString))
#endif
	{
			printf( "no get this str\n");
			return NULL;
	}

	Fl_Menu_ *theMenu;
	//char *thisPtrAsCString = PyString_AsString(thisPtrString);
	//SWIG_GetPtr( thisPtrAsCString, (void **)&theMenu, "_Fl_Menu_p");
	SWIG_ConvertPtr(thisPtrString, (void **)&theMenu, SWIGTYPE_p_Fl_Menu_, 0);

	Fl_Menu_Item *theMenuItems = createFl_Menu_Item_Array( NULL, menuList);

	// call the C++ object to add the menu
	theMenu->copy( theMenuItems, NULL );

	delete [] theMenuItems;

	Py_INCREF(Py_None);
	return Py_None;

}




/* ---------------------------------------------------
 * C++ director class methods
 * --------------------------------------------------- */

#include "fltk_wrap.h"

SwigDirector_Fl_Image::SwigDirector_Fl_Image(PyObject *self,int W,int H,int D): Fl_Image(W, H, D), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Image *)this, this); 
}




void SwigDirector_Fl_Image::release() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "release";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("release");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Shared_Image *SwigDirector_Fl_Image::as_shared_image() {
  Fl_Shared_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "as_shared_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_shared_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Shared_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Shared_Image *""'");
  }
  c_result = (Fl_Shared_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Shared_Image *) c_result;
}


SwigDirector_Fl_Image::~SwigDirector_Fl_Image() {
}

Fl_Image *SwigDirector_Fl_Image::copy(int W,int H) const {
  Fl_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "copy";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("copy");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Image *""'");
  }
  c_result = (Fl_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Image *) c_result;
}


void SwigDirector_Fl_Image::color_average(Fl_Color c,float i) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_unsigned_SS_int((unsigned int)(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(i));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "color_average";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("color_average");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Image::desaturate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "desaturate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("desaturate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Image::label(Fl_Widget *w) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(w), SWIGTYPE_p_Fl_Widget,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Image::label(Fl_Menu_Item *m) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(m), SWIGTYPE_p_Fl_Menu_Item,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Image::draw(int X,int Y,int W,int H,int cx,int cy) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int((int)(cy));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Image::uncache() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "uncache";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("uncache");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Image::scale(int width,int height,int proportional,int can_expand) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(width));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(height));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(proportional));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(can_expand));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_RGB_Image::SwigDirector_Fl_RGB_Image(PyObject *self,uchar const *bits,int W,int H,int D,int LD): Fl_RGB_Image(bits, W, H, D, LD), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_RGB_Image *)this, this); 
}




SwigDirector_Fl_RGB_Image::SwigDirector_Fl_RGB_Image(PyObject *self,uchar const *bits,int bits_length,int W,int H,int D,int LD): Fl_RGB_Image(bits, bits_length, W, H, D, LD), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_RGB_Image *)this, this); 
}




SwigDirector_Fl_RGB_Image::SwigDirector_Fl_RGB_Image(PyObject *self,Fl_Pixmap const *pxm,Fl_Color bg): Fl_RGB_Image(pxm, bg), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_RGB_Image *)this, this); 
}




void SwigDirector_Fl_RGB_Image::release() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_RGB_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "release";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("release");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Shared_Image *SwigDirector_Fl_RGB_Image::as_shared_image() {
  Fl_Shared_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_RGB_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "as_shared_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_shared_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Shared_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Shared_Image *""'");
  }
  c_result = (Fl_Shared_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Shared_Image *) c_result;
}


SwigDirector_Fl_RGB_Image::~SwigDirector_Fl_RGB_Image() {
}

Fl_Image *SwigDirector_Fl_RGB_Image::copy(int W,int H) const {
  Fl_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_RGB_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "copy";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("copy");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Image *""'");
  }
  c_result = (Fl_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Image *) c_result;
}


void SwigDirector_Fl_RGB_Image::color_average(Fl_Color c,float i) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_unsigned_SS_int((unsigned int)(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(i));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_RGB_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "color_average";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("color_average");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_RGB_Image::desaturate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_RGB_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "desaturate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("desaturate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_RGB_Image::label(Fl_Widget *w) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(w), SWIGTYPE_p_Fl_Widget,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_RGB_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_RGB_Image::label(Fl_Menu_Item *m) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(m), SWIGTYPE_p_Fl_Menu_Item,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_RGB_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_RGB_Image::draw(int X,int Y,int W,int H,int cx,int cy) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int((int)(cy));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_RGB_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_RGB_Image::uncache() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_RGB_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "uncache";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("uncache");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_RGB_Image::scale(int width,int height,int proportional,int can_expand) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(width));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(height));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(proportional));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(can_expand));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_RGB_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_SVG_Image *SwigDirector_Fl_RGB_Image::as_svg_image() {
  Fl_SVG_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_RGB_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_svg_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_svg_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_SVG_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_SVG_Image *""'");
  }
  c_result = (Fl_SVG_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_SVG_Image *) c_result;
}


void SwigDirector_Fl_RGB_Image::normalize() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_RGB_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "normalize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("normalize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Callback_User_Data::SwigDirector_Fl_Callback_User_Data(PyObject *self): Fl_Callback_User_Data(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Callback_User_Data *)this, this); 
}




SwigDirector_Fl_Callback_User_Data::~SwigDirector_Fl_Callback_User_Data() {
}

SwigDirector_Fl_Widget::SwigDirector_Fl_Widget(PyObject *self,int x,int y,int w,int h,char const *label): Fl_Widget(x, y, w, h, label), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Widget *)this, this); 
}




SwigDirector_Fl_Widget::~SwigDirector_Fl_Widget() {
}

void SwigDirector_Fl_Widget::draw() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Widget.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Widget::handle(int event) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Widget.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Widget::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Widget.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Widget::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Widget.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Widget::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Widget.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Widget::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Widget.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Widget::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Widget.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Widget::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Widget.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Widget::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Widget.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Widget::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Widget.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Widget::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Widget.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Widget::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Widget.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Widget::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Widget.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Group::SwigDirector_Fl_Group(PyObject *self,int arg0,int arg1,int arg2,int arg3,char const *arg4): Fl_Group(arg0, arg1, arg2, arg3, arg4), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Group *)this, this); 
}




SwigDirector_Fl_Group::~SwigDirector_Fl_Group() {
}

void SwigDirector_Fl_Group::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Group.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Group::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Group.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Group::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Group.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Group::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Group.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Group::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Group.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Group::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Group.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Group::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Group.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Group::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Group.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Group::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Group.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Group::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Group.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Group::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Group.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Group::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Group.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Group::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Group.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Group::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Group::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Group::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Group::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Group.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Browser_::SwigDirector_Fl_Browser_(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Browser_(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Browser_ *)this, this); 
}




SwigDirector_Fl_Browser_::~SwigDirector_Fl_Browser_() {
}

void SwigDirector_Fl_Browser_::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Browser_::handle(int event) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Browser_::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Browser_::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Browser_::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Browser_::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Browser_::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Browser_::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Browser_::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Browser_::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Browser_::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Browser_::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Browser_::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Browser_::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Browser_::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Browser_::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Browser_::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void *SwigDirector_Fl_Browser_::item_first() const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig_set_inner("item_first", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "item_first";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_first");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("item_first", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Browser_::item_next(void *item) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_next", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "item_next";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_next");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_next", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Browser_::item_prev(void *item) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_prev", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 16;
  const char *const swig_method_name = "item_prev";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_prev");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_prev", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Browser_::item_last() const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig_set_inner("item_last", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 17;
  const char *const swig_method_name = "item_last";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_last");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("item_last", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Browser_::item_height(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 18;
  const char *const swig_method_name = "item_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Browser_::item_width(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_width", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 19;
  const char *const swig_method_name = "item_width";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_width");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_width", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Browser_::item_quick_height(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_quick_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 20;
  const char *const swig_method_name = "item_quick_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_quick_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_quick_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Browser_::item_draw(void *item,int X,int Y,int W,int H) const {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(H));
  swig_set_inner("item_draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 21;
  const char *const swig_method_name = "item_draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#endif
  swig_set_inner("item_draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


char const *SwigDirector_Fl_Browser_::item_text(void *item) const {
  char *c_result = 0 ;
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_text", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 22;
  const char *const swig_method_name = "item_text";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_text");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_text", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_AsCharPtrAndSize(result, &buf, NULL, &alloc);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""char const *""'");
  }
  if (alloc == SWIG_NEWOBJ) {
    swig_acquire_ownership_array(buf);
  }
  c_result = (char *)(buf);
  return (char const *) c_result;
}


void SwigDirector_Fl_Browser_::item_swap(void *a,void *b) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(a), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(b), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_swap", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 23;
  const char *const swig_method_name = "item_swap";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_swap");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  swig_set_inner("item_swap", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void *SwigDirector_Fl_Browser_::item_at(int index) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(index));
  swig_set_inner("item_at", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 24;
  const char *const swig_method_name = "item_at";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_at");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_at", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Browser_::full_width() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("full_width", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 25;
  const char *const swig_method_name = "full_width";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("full_width");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("full_width", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Browser_::full_height() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("full_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 26;
  const char *const swig_method_name = "full_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("full_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("full_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Browser_::incr_height() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("incr_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 27;
  const char *const swig_method_name = "incr_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("incr_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("incr_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Browser_::item_select(void *item,int val) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(val));
  swig_set_inner("item_select", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 28;
  const char *const swig_method_name = "item_select";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_select");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  swig_set_inner("item_select", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Browser_::item_selected(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_selected", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 29;
  const char *const swig_method_name = "item_selected";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_selected");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_selected", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Browser::SwigDirector_Fl_Browser(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Browser(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Browser *)this, this); 
}




SwigDirector_Fl_Browser::~SwigDirector_Fl_Browser() {
}

void SwigDirector_Fl_Browser::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Browser::handle(int event) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Browser::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Browser::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Browser::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Browser::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Browser::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Browser::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Browser::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Browser::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Browser::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Browser::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Browser::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Browser::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Browser::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Browser::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Browser::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void *SwigDirector_Fl_Browser::item_first() const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig_set_inner("item_first", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "item_first";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_first");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("item_first", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Browser::item_next(void *item) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_next", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "item_next";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_next");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_next", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Browser::item_prev(void *item) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_prev", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 16;
  const char *const swig_method_name = "item_prev";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_prev");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_prev", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Browser::item_last() const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig_set_inner("item_last", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 17;
  const char *const swig_method_name = "item_last";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_last");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("item_last", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Browser::item_height(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 18;
  const char *const swig_method_name = "item_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Browser::item_width(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_width", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 19;
  const char *const swig_method_name = "item_width";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_width");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_width", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Browser::item_quick_height(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_quick_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 20;
  const char *const swig_method_name = "item_quick_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_quick_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_quick_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Browser::item_draw(void *item,int X,int Y,int W,int H) const {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(H));
  swig_set_inner("item_draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 21;
  const char *const swig_method_name = "item_draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#endif
  swig_set_inner("item_draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


char const *SwigDirector_Fl_Browser::item_text(void *item) const {
  char *c_result = 0 ;
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_text", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 22;
  const char *const swig_method_name = "item_text";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_text");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_text", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_AsCharPtrAndSize(result, &buf, NULL, &alloc);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""char const *""'");
  }
  if (alloc == SWIG_NEWOBJ) {
    swig_acquire_ownership_array(buf);
  }
  c_result = (char *)(buf);
  return (char const *) c_result;
}


void SwigDirector_Fl_Browser::item_swap(void *a,void *b) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(a), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(b), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_swap", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 23;
  const char *const swig_method_name = "item_swap";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_swap");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  swig_set_inner("item_swap", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void *SwigDirector_Fl_Browser::item_at(int line) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(line));
  swig_set_inner("item_at", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 24;
  const char *const swig_method_name = "item_at";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_at");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_at", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Browser::full_width() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("full_width", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 25;
  const char *const swig_method_name = "full_width";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("full_width");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("full_width", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Browser::full_height() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("full_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 26;
  const char *const swig_method_name = "full_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("full_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("full_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Browser::incr_height() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("incr_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 27;
  const char *const swig_method_name = "incr_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("incr_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("incr_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Browser::item_select(void *item,int val) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(val));
  swig_set_inner("item_select", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 28;
  const char *const swig_method_name = "item_select";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_select");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  swig_set_inner("item_select", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Browser::item_selected(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_selected", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 29;
  const char *const swig_method_name = "item_selected";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_selected");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_selected", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_File_Browser::SwigDirector_Fl_File_Browser(PyObject *self,int arg0,int arg1,int arg2,int arg3,char const *arg4): Fl_File_Browser(arg0, arg1, arg2, arg3, arg4), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_File_Browser *)this, this); 
}




SwigDirector_Fl_File_Browser::~SwigDirector_Fl_File_Browser() {
}

void SwigDirector_Fl_File_Browser::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_File_Browser::handle(int event) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_File_Browser::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_File_Browser::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_File_Browser::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_File_Browser::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_File_Browser::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_File_Browser::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_File_Browser::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_File_Browser::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_File_Browser::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_File_Browser::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_File_Browser::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_File_Browser::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_File_Browser::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_File_Browser::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_File_Browser::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void *SwigDirector_Fl_File_Browser::item_first() const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig_set_inner("item_first", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "item_first";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_first");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("item_first", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_File_Browser::item_next(void *item) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_next", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "item_next";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_next");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_next", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_File_Browser::item_prev(void *item) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_prev", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 16;
  const char *const swig_method_name = "item_prev";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_prev");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_prev", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_File_Browser::item_last() const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig_set_inner("item_last", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 17;
  const char *const swig_method_name = "item_last";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_last");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("item_last", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_File_Browser::item_height(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 18;
  const char *const swig_method_name = "item_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_File_Browser::item_width(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_width", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 19;
  const char *const swig_method_name = "item_width";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_width");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_width", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_File_Browser::item_quick_height(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_quick_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 20;
  const char *const swig_method_name = "item_quick_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_quick_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_quick_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_File_Browser::item_draw(void *item,int X,int Y,int W,int H) const {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(H));
  swig_set_inner("item_draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 21;
  const char *const swig_method_name = "item_draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#endif
  swig_set_inner("item_draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


char const *SwigDirector_Fl_File_Browser::item_text(void *item) const {
  char *c_result = 0 ;
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_text", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 22;
  const char *const swig_method_name = "item_text";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_text");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_text", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_AsCharPtrAndSize(result, &buf, NULL, &alloc);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""char const *""'");
  }
  if (alloc == SWIG_NEWOBJ) {
    swig_acquire_ownership_array(buf);
  }
  c_result = (char *)(buf);
  return (char const *) c_result;
}


void SwigDirector_Fl_File_Browser::item_swap(void *a,void *b) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(a), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(b), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_swap", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 23;
  const char *const swig_method_name = "item_swap";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_swap");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  swig_set_inner("item_swap", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void *SwigDirector_Fl_File_Browser::item_at(int line) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(line));
  swig_set_inner("item_at", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 24;
  const char *const swig_method_name = "item_at";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_at");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_at", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_File_Browser::full_width() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("full_width", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 25;
  const char *const swig_method_name = "full_width";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("full_width");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("full_width", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_File_Browser::full_height() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("full_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 26;
  const char *const swig_method_name = "full_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("full_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("full_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_File_Browser::incr_height() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("incr_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 27;
  const char *const swig_method_name = "incr_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("incr_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("incr_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_File_Browser::item_select(void *item,int val) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(val));
  swig_set_inner("item_select", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 28;
  const char *const swig_method_name = "item_select";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_select");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  swig_set_inner("item_select", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_File_Browser::item_selected(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_selected", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 29;
  const char *const swig_method_name = "item_selected";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_selected");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_selected", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Valuator::SwigDirector_Fl_Valuator(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Valuator(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Valuator *)this, this); 
}




SwigDirector_Fl_Valuator::~SwigDirector_Fl_Valuator() {
}

void SwigDirector_Fl_Valuator::draw() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Valuator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Valuator::handle(int event) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Valuator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Valuator::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Valuator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Valuator::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Valuator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Valuator::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Valuator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Valuator::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Valuator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Valuator::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Valuator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Valuator::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Valuator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Valuator::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Valuator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Valuator::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Valuator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Valuator::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Valuator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Valuator::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Valuator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Valuator::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Valuator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Valuator::format(char *format_string) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)format_string);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Valuator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Adjuster::SwigDirector_Fl_Adjuster(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Adjuster(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Adjuster *)this, this); 
}




SwigDirector_Fl_Adjuster::~SwigDirector_Fl_Adjuster() {
}

void SwigDirector_Fl_Adjuster::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Adjuster.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Adjuster::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig_set_inner("handle", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Adjuster.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("handle", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Adjuster::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Adjuster.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Adjuster::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Adjuster.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Adjuster::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Adjuster.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Adjuster::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Adjuster.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Adjuster::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Adjuster.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Adjuster::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Adjuster.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Adjuster::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Adjuster.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Adjuster::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Adjuster.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Adjuster::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Adjuster.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Adjuster::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Adjuster.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Adjuster::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Adjuster.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Adjuster::format(char *format_string) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)format_string);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Adjuster.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Bitmap::SwigDirector_Fl_Bitmap(PyObject *self,uchar const *bits,int W,int H): Fl_Bitmap(bits, W, H), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Bitmap *)this, this); 
}




SwigDirector_Fl_Bitmap::SwigDirector_Fl_Bitmap(PyObject *self,uchar const *bits,int bits_length,int W,int H): Fl_Bitmap(bits, bits_length, W, H), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Bitmap *)this, this); 
}




SwigDirector_Fl_Bitmap::SwigDirector_Fl_Bitmap(PyObject *self,char const *bits,int bits_length,int W,int H): Fl_Bitmap(bits, bits_length, W, H), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Bitmap *)this, this); 
}




void SwigDirector_Fl_Bitmap::release() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Bitmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "release";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("release");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Shared_Image *SwigDirector_Fl_Bitmap::as_shared_image() {
  Fl_Shared_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Bitmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "as_shared_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_shared_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Shared_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Shared_Image *""'");
  }
  c_result = (Fl_Shared_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Shared_Image *) c_result;
}


SwigDirector_Fl_Bitmap::~SwigDirector_Fl_Bitmap() {
}

Fl_Image *SwigDirector_Fl_Bitmap::copy(int W,int H) const {
  Fl_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Bitmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "copy";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("copy");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Image *""'");
  }
  c_result = (Fl_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Image *) c_result;
}


void SwigDirector_Fl_Bitmap::color_average(Fl_Color c,float i) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_unsigned_SS_int((unsigned int)(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(i));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Bitmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "color_average";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("color_average");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Bitmap::desaturate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Bitmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "desaturate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("desaturate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Bitmap::label(Fl_Widget *w) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(w), SWIGTYPE_p_Fl_Widget,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Bitmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Bitmap::label(Fl_Menu_Item *m) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(m), SWIGTYPE_p_Fl_Menu_Item,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Bitmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Bitmap::draw(int X,int Y,int W,int H,int cx,int cy) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int((int)(cy));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Bitmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Bitmap::uncache() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Bitmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "uncache";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("uncache");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Bitmap::scale(int width,int height,int proportional,int can_expand) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(width));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(height));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(proportional));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(can_expand));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Bitmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_BMP_Image::SwigDirector_Fl_BMP_Image(PyObject *self,char const *filename): Fl_BMP_Image(filename), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_BMP_Image *)this, this); 
}




SwigDirector_Fl_BMP_Image::SwigDirector_Fl_BMP_Image(PyObject *self,char const *imagename,unsigned char const *data,long const length): Fl_BMP_Image(imagename, data, length), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_BMP_Image *)this, this); 
}




void SwigDirector_Fl_BMP_Image::release() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_BMP_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "release";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("release");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Shared_Image *SwigDirector_Fl_BMP_Image::as_shared_image() {
  Fl_Shared_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_BMP_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "as_shared_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_shared_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Shared_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Shared_Image *""'");
  }
  c_result = (Fl_Shared_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Shared_Image *) c_result;
}


SwigDirector_Fl_BMP_Image::~SwigDirector_Fl_BMP_Image() {
}

Fl_Image *SwigDirector_Fl_BMP_Image::copy(int W,int H) const {
  Fl_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_BMP_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "copy";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("copy");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Image *""'");
  }
  c_result = (Fl_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Image *) c_result;
}


void SwigDirector_Fl_BMP_Image::color_average(Fl_Color c,float i) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_unsigned_SS_int((unsigned int)(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(i));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_BMP_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "color_average";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("color_average");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_BMP_Image::desaturate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_BMP_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "desaturate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("desaturate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_BMP_Image::label(Fl_Widget *w) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(w), SWIGTYPE_p_Fl_Widget,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_BMP_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_BMP_Image::label(Fl_Menu_Item *m) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(m), SWIGTYPE_p_Fl_Menu_Item,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_BMP_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_BMP_Image::draw(int X,int Y,int W,int H,int cx,int cy) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int((int)(cy));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_BMP_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_BMP_Image::uncache() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_BMP_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "uncache";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("uncache");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_BMP_Image::scale(int width,int height,int proportional,int can_expand) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(width));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(height));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(proportional));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(can_expand));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_BMP_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_SVG_Image *SwigDirector_Fl_BMP_Image::as_svg_image() {
  Fl_SVG_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_BMP_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_svg_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_svg_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_SVG_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_SVG_Image *""'");
  }
  c_result = (Fl_SVG_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_SVG_Image *) c_result;
}


void SwigDirector_Fl_BMP_Image::normalize() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_BMP_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "normalize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("normalize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Box::SwigDirector_Fl_Box(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Box(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Box *)this, this); 
}




SwigDirector_Fl_Box::SwigDirector_Fl_Box(PyObject *self,Fl_Boxtype B,int X,int Y,int W,int H,char const *L): Fl_Box(B, X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Box *)this, this); 
}




SwigDirector_Fl_Box::~SwigDirector_Fl_Box() {
}

void SwigDirector_Fl_Box::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Box.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Box::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Box.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Box::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Box.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Box::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Box.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Box::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Box.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Box::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Box.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Box::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Box.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Box::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Box.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Box::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Box.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Box::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Box.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Box::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Box.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Box::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Box.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Box::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Box.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Button::SwigDirector_Fl_Button(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Button(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Button *)this, this); 
}




SwigDirector_Fl_Button::~SwigDirector_Fl_Button() {
}

void SwigDirector_Fl_Button::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Button::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Button::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Button::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Button::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Button::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Button::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Button::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Button::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Button::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Button::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Button::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Button::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Shortcut_Button::SwigDirector_Fl_Shortcut_Button(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Shortcut_Button(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Shortcut_Button *)this, this); 
}




SwigDirector_Fl_Shortcut_Button::~SwigDirector_Fl_Shortcut_Button() {
}

void SwigDirector_Fl_Shortcut_Button::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shortcut_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Shortcut_Button::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig_set_inner("handle", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shortcut_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("handle", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Shortcut_Button::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shortcut_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Shortcut_Button::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shortcut_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Shortcut_Button::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shortcut_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Shortcut_Button::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shortcut_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Shortcut_Button::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shortcut_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Shortcut_Button::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shortcut_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Shortcut_Button::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shortcut_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Shortcut_Button::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shortcut_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Shortcut_Button::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shortcut_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Shortcut_Button::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shortcut_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Shortcut_Button::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shortcut_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Chart::SwigDirector_Fl_Chart(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Chart(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Chart *)this, this); 
}




SwigDirector_Fl_Chart::~SwigDirector_Fl_Chart() {
}

void SwigDirector_Fl_Chart::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Chart.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Chart::handle(int event) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Chart.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Chart::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Chart.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Chart::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Chart.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Chart::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Chart.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Chart::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Chart.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Chart::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Chart.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Chart::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Chart.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Chart::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Chart.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Chart::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Chart.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Chart::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Chart.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Chart::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Chart.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Chart::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Chart.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Check_Browser::SwigDirector_Fl_Check_Browser(PyObject *self,int x,int y,int w,int h,char const *l): Fl_Check_Browser(x, y, w, h, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Check_Browser *)this, this); 
}




SwigDirector_Fl_Check_Browser::~SwigDirector_Fl_Check_Browser() {
}

void SwigDirector_Fl_Check_Browser::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Check_Browser::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig_set_inner("handle", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("handle", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Check_Browser::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Check_Browser::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Check_Browser::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Check_Browser::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Check_Browser::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Check_Browser::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Check_Browser::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Check_Browser::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Check_Browser::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Check_Browser::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Check_Browser::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Check_Browser::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Check_Browser::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Check_Browser::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Check_Browser::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void *SwigDirector_Fl_Check_Browser::item_first() const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig_set_inner("item_first", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "item_first";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_first");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("item_first", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Check_Browser::item_next(void *arg0) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(arg0), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_next", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "item_next";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_next");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_next", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Check_Browser::item_prev(void *arg0) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(arg0), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_prev", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 16;
  const char *const swig_method_name = "item_prev";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_prev");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_prev", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Check_Browser::item_last() const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig_set_inner("item_last", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 17;
  const char *const swig_method_name = "item_last";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_last");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("item_last", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Check_Browser::item_height(void *arg0) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(arg0), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 18;
  const char *const swig_method_name = "item_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Check_Browser::item_width(void *arg0) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(arg0), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_width", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 19;
  const char *const swig_method_name = "item_width";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_width");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_width", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Check_Browser::item_quick_height(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_quick_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 20;
  const char *const swig_method_name = "item_quick_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_quick_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_quick_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Check_Browser::item_draw(void *arg0,int arg1,int arg2,int arg3,int arg4) const {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(arg0), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(arg4));
  swig_set_inner("item_draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 21;
  const char *const swig_method_name = "item_draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#endif
  swig_set_inner("item_draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


char const *SwigDirector_Fl_Check_Browser::item_text(void *item) const {
  char *c_result = 0 ;
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_text", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 22;
  const char *const swig_method_name = "item_text";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_text");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_text", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_AsCharPtrAndSize(result, &buf, NULL, &alloc);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""char const *""'");
  }
  if (alloc == SWIG_NEWOBJ) {
    swig_acquire_ownership_array(buf);
  }
  c_result = (char *)(buf);
  return (char const *) c_result;
}


void SwigDirector_Fl_Check_Browser::item_swap(void *a,void *b) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(a), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(b), SWIGTYPE_p_void,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 23;
  const char *const swig_method_name = "item_swap";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_swap");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void *SwigDirector_Fl_Check_Browser::item_at(int index) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(index));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 24;
  const char *const swig_method_name = "item_at";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_at");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Check_Browser::full_width() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("full_width", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 25;
  const char *const swig_method_name = "full_width";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("full_width");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("full_width", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Check_Browser::full_height() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("full_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 26;
  const char *const swig_method_name = "full_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("full_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("full_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Check_Browser::incr_height() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("incr_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 27;
  const char *const swig_method_name = "incr_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("incr_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("incr_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Check_Browser::item_select(void *arg0,int arg1) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(arg0), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig_set_inner("item_select", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 28;
  const char *const swig_method_name = "item_select";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_select");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  swig_set_inner("item_select", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Check_Browser::item_selected(void *arg0) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(arg0), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_selected", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 29;
  const char *const swig_method_name = "item_selected";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_selected");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_selected", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Light_Button::SwigDirector_Fl_Light_Button(PyObject *self,int x,int y,int w,int h,char const *l): Fl_Light_Button(x, y, w, h, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Light_Button *)this, this); 
}




SwigDirector_Fl_Light_Button::~SwigDirector_Fl_Light_Button() {
}

void SwigDirector_Fl_Light_Button::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Light_Button::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Light_Button::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Light_Button::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Light_Button::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Light_Button::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Light_Button::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Light_Button::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Light_Button::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Light_Button::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Light_Button::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Light_Button::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Light_Button::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Check_Button::SwigDirector_Fl_Check_Button(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Check_Button(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Check_Button *)this, this); 
}




SwigDirector_Fl_Check_Button::~SwigDirector_Fl_Check_Button() {
}

void SwigDirector_Fl_Check_Button::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Check_Button::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Check_Button::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Check_Button::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Check_Button::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Check_Button::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Check_Button::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Check_Button::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Check_Button::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Check_Button::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Check_Button::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Check_Button::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Check_Button::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Check_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Menu_::SwigDirector_Fl_Menu_(PyObject *self,int arg0,int arg1,int arg2,int arg3,char const *arg4): Fl_Menu_(arg0, arg1, arg2, arg3, arg4), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Menu_ *)this, this); 
}




SwigDirector_Fl_Menu_::~SwigDirector_Fl_Menu_() {
}

void SwigDirector_Fl_Menu_::draw() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Menu_::handle(int event) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Menu_::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Menu_::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Menu_::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Menu_::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Menu_::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Menu_::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Menu_::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Menu_::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Menu_::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Menu_::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Menu_::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Choice::SwigDirector_Fl_Choice(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Choice(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Choice *)this, this); 
}




SwigDirector_Fl_Choice::~SwigDirector_Fl_Choice() {
}

void SwigDirector_Fl_Choice::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Choice::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Choice::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Choice::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Choice::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Choice::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Choice::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Choice::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Choice::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Choice::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Choice::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Choice::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Choice::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Clock_Output::SwigDirector_Fl_Clock_Output(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Clock_Output(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Clock_Output *)this, this); 
}




SwigDirector_Fl_Clock_Output::~SwigDirector_Fl_Clock_Output() {
}

void SwigDirector_Fl_Clock_Output::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Clock_Output::handle(int event) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Clock_Output::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Clock_Output::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Clock_Output::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Clock_Output::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Clock_Output::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Clock_Output::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Clock_Output::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Clock_Output::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Clock_Output::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Clock_Output::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Clock_Output::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Clock::SwigDirector_Fl_Clock(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Clock(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Clock *)this, this); 
}




SwigDirector_Fl_Clock::SwigDirector_Fl_Clock(PyObject *self,uchar t,int X,int Y,int W,int H,char const *L): Fl_Clock(t, X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Clock *)this, this); 
}




SwigDirector_Fl_Clock::~SwigDirector_Fl_Clock() {
}

void SwigDirector_Fl_Clock::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Clock::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Clock::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Clock::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Clock::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Clock::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Clock::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Clock::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Clock::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Clock::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Clock::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Clock::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Clock::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Value_Input::SwigDirector_Fl_Value_Input(PyObject *self,int x,int y,int w,int h,char const *l): Fl_Value_Input(x, y, w, h, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Value_Input *)this, this); 
}




SwigDirector_Fl_Value_Input::~SwigDirector_Fl_Value_Input() {
}

void SwigDirector_Fl_Value_Input::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Value_Input::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Value_Input::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Value_Input::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Value_Input::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Value_Input::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Value_Input::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Value_Input::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Value_Input::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Value_Input::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Value_Input::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Value_Input::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Value_Input::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Value_Input::format(char *format_string) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)format_string);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Flcc_HueBox::SwigDirector_Flcc_HueBox(PyObject *self,int X,int Y,int W,int H): Flcc_HueBox(X, Y, W, H), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Flcc_HueBox *)this, this); 
}




SwigDirector_Flcc_HueBox::~SwigDirector_Flcc_HueBox() {
}

void SwigDirector_Flcc_HueBox::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_HueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Flcc_HueBox::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_HueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Flcc_HueBox::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_HueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Flcc_HueBox::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_HueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Flcc_HueBox::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_HueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Flcc_HueBox::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_HueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Flcc_HueBox::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_HueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Flcc_HueBox::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_HueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Flcc_HueBox::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_HueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Flcc_HueBox::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_HueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Flcc_HueBox::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_HueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Flcc_HueBox::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_HueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Flcc_HueBox::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_HueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Flcc_ValueBox::SwigDirector_Flcc_ValueBox(PyObject *self,int X,int Y,int W,int H): Flcc_ValueBox(X, Y, W, H), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Flcc_ValueBox *)this, this); 
}




SwigDirector_Flcc_ValueBox::~SwigDirector_Flcc_ValueBox() {
}

void SwigDirector_Flcc_ValueBox::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_ValueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Flcc_ValueBox::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_ValueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Flcc_ValueBox::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_ValueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Flcc_ValueBox::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_ValueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Flcc_ValueBox::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_ValueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Flcc_ValueBox::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_ValueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Flcc_ValueBox::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_ValueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Flcc_ValueBox::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_ValueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Flcc_ValueBox::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_ValueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Flcc_ValueBox::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_ValueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Flcc_ValueBox::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_ValueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Flcc_ValueBox::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_ValueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Flcc_ValueBox::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_ValueBox.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Flcc_Value_Input::SwigDirector_Flcc_Value_Input(PyObject *self,int X,int Y,int W,int H): Flcc_Value_Input(X, Y, W, H), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Flcc_Value_Input *)this, this); 
}




SwigDirector_Flcc_Value_Input::~SwigDirector_Flcc_Value_Input() {
}

void SwigDirector_Flcc_Value_Input::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Flcc_Value_Input::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Flcc_Value_Input::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Flcc_Value_Input::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Flcc_Value_Input::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Flcc_Value_Input::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Flcc_Value_Input::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Flcc_Value_Input::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Flcc_Value_Input::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Flcc_Value_Input::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Flcc_Value_Input::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Flcc_Value_Input::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Flcc_Value_Input::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Flcc_Value_Input::format(char *arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)arg0);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Flcc_Value_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Color_Chooser::SwigDirector_Fl_Color_Chooser(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Color_Chooser(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Color_Chooser *)this, this); 
}




SwigDirector_Fl_Color_Chooser::~SwigDirector_Fl_Color_Chooser() {
}

void SwigDirector_Fl_Color_Chooser::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Color_Chooser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Color_Chooser::handle(int e) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(e));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Color_Chooser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Color_Chooser::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Color_Chooser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Color_Chooser::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Color_Chooser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Color_Chooser::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Color_Chooser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Color_Chooser::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Color_Chooser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Color_Chooser::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Color_Chooser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Color_Chooser::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Color_Chooser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Color_Chooser::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Color_Chooser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Color_Chooser::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Color_Chooser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Color_Chooser::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Color_Chooser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Color_Chooser::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Color_Chooser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Color_Chooser::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Color_Chooser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Color_Chooser::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Color_Chooser::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Color_Chooser::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Color_Chooser::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Color_Chooser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Counter::SwigDirector_Fl_Counter(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Counter(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Counter *)this, this); 
}




SwigDirector_Fl_Counter::~SwigDirector_Fl_Counter() {
}

void SwigDirector_Fl_Counter::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Counter::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Counter::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Counter::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Counter::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Counter::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Counter::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Counter::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Counter::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Counter::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Counter::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Counter::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Counter::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Counter::format(char *format_string) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)format_string);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Plugin::SwigDirector_Fl_Plugin(PyObject *self,char const *klass,char const *name): Fl_Plugin(klass, name), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Plugin *)this, this); 
}




SwigDirector_Fl_Plugin::~SwigDirector_Fl_Plugin() {
}

SwigDirector_Fl_Surface_Device::SwigDirector_Fl_Surface_Device(PyObject *self,Fl_Graphics_Driver *graphics_driver): Fl_Surface_Device(graphics_driver), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Surface_Device *)this, this); 
}




void SwigDirector_Fl_Surface_Device::end_current() {
  swig_set_inner("end_current", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Surface_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "end_current";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("end_current");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("end_current", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Surface_Device::set_current() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Surface_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "set_current";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("set_current");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


bool SwigDirector_Fl_Surface_Device::is_current() {
  bool c_result = SwigValueInit< bool >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Surface_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "is_current";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("is_current");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = (bool)(swig_val);
  return (bool) c_result;
}


SwigDirector_Fl_Surface_Device::~SwigDirector_Fl_Surface_Device() {
}

void SwigDirector_Fl_Display_Device::end_current() {
  swig_set_inner("end_current", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Display_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "end_current";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("end_current");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("end_current", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Display_Device::set_current() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Display_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "set_current";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("set_current");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


bool SwigDirector_Fl_Display_Device::is_current() {
  bool c_result = SwigValueInit< bool >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Display_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "is_current";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("is_current");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = (bool)(swig_val);
  return (bool) c_result;
}


SwigDirector_Fl_Display_Device::~SwigDirector_Fl_Display_Device() {
}

SwigDirector_Fl_Device_Plugin::SwigDirector_Fl_Device_Plugin(PyObject *self,char const *pluginName): Fl_Device_Plugin(pluginName), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Device_Plugin *)this, this); 
}




SwigDirector_Fl_Device_Plugin::~SwigDirector_Fl_Device_Plugin() {
}

char const *SwigDirector_Fl_Device_Plugin::klass() {
  char *c_result = 0 ;
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Device_Plugin.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "klass";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("klass");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_AsCharPtrAndSize(result, &buf, NULL, &alloc);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""char const *""'");
  }
  if (alloc == SWIG_NEWOBJ) {
    swig_acquire_ownership_array(buf);
  }
  c_result = (char *)(buf);
  return (char const *) c_result;
}


char const *SwigDirector_Fl_Device_Plugin::name() {
  char *c_result = 0 ;
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Device_Plugin.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "name";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("name");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_AsCharPtrAndSize(result, &buf, NULL, &alloc);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""char const *""'");
  }
  if (alloc == SWIG_NEWOBJ) {
    swig_acquire_ownership_array(buf);
  }
  c_result = (char *)(buf);
  return (char const *) c_result;
}


int SwigDirector_Fl_Device_Plugin::print(Fl_Widget *w) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(w), SWIGTYPE_p_Fl_Widget,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Device_Plugin.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "_print";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("_print");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


Fl_RGB_Image *SwigDirector_Fl_Device_Plugin::rectangle_capture(Fl_Widget *widget,int x,int y,int w,int h) {
  Fl_RGB_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(widget), SWIGTYPE_p_Fl_Widget,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Device_Plugin.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "rectangle_capture";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("rectangle_capture");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_RGB_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_RGB_Image *""'");
  }
  c_result = (Fl_RGB_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_RGB_Image *) c_result;
}


SwigDirector_Fl_Dial::SwigDirector_Fl_Dial(PyObject *self,int x,int y,int w,int h,char const *l): Fl_Dial(x, y, w, h, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Dial *)this, this); 
}




SwigDirector_Fl_Dial::~SwigDirector_Fl_Dial() {
}

void SwigDirector_Fl_Dial::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Dial::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Dial::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Dial::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Dial::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Dial::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Dial::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Dial::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Dial::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Dial::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Dial::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Dial::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Dial::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Dial::format(char *format_string) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)format_string);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Window::SwigDirector_Fl_Window(PyObject *self,int w,int h,char const *title): Fl_Window(w, h, title), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Window *)this, this); 
}




SwigDirector_Fl_Window::SwigDirector_Fl_Window(PyObject *self,int x,int y,int w,int h,char const *title): Fl_Window(x, y, w, h, title), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Window *)this, this); 
}




SwigDirector_Fl_Window::~SwigDirector_Fl_Window() {
}

void SwigDirector_Fl_Window::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Window::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Window::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Window::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Window::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Window::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Window::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Window::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Window::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Window::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Window::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Window::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Window::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Window::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Window::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Window::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Window::flush() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "flush";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("flush");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Overlay_Window *SwigDirector_Fl_Window::as_overlay_window() {
  Fl_Overlay_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "as_overlay_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_overlay_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Overlay_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Overlay_Window *""'");
  }
  c_result = (Fl_Overlay_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Overlay_Window *) c_result;
}


Fl_Double_Window *SwigDirector_Fl_Window::as_double_window() {
  Fl_Double_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "as_double_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_double_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Double_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Double_Window *""'");
  }
  c_result = (Fl_Double_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Double_Window *) c_result;
}


SwigDirector_Fl_Double_Window::SwigDirector_Fl_Double_Window(PyObject *self,int W,int H,char const *l): Fl_Double_Window(W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Double_Window *)this, this); 
}




SwigDirector_Fl_Double_Window::SwigDirector_Fl_Double_Window(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Double_Window(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Double_Window *)this, this); 
}




SwigDirector_Fl_Double_Window::~SwigDirector_Fl_Double_Window() {
}

void SwigDirector_Fl_Double_Window::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Double_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Double_Window::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Double_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Double_Window::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Double_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Double_Window::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Double_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Double_Window::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Double_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Double_Window::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Double_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Double_Window::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Double_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Double_Window::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Double_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Double_Window::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Double_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Double_Window::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Double_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Double_Window::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Double_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Double_Window::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Double_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Double_Window::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Double_Window::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Double_Window::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Double_Window::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Double_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Double_Window::flush() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Double_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "flush";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("flush");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Overlay_Window *SwigDirector_Fl_Double_Window::as_overlay_window() {
  Fl_Overlay_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Double_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "as_overlay_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_overlay_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Overlay_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Overlay_Window *""'");
  }
  c_result = (Fl_Overlay_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Overlay_Window *) c_result;
}


Fl_Double_Window *SwigDirector_Fl_Double_Window::as_double_window() {
  Fl_Double_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Double_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "as_double_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_double_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Double_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Double_Window *""'");
  }
  c_result = (Fl_Double_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Double_Window *) c_result;
}


SwigDirector_Fl_Input_::SwigDirector_Fl_Input_(PyObject *self,int arg0,int arg1,int arg2,int arg3,char const *arg4): Fl_Input_(arg0, arg1, arg2, arg3, arg4), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Input_ *)this, this); 
}




SwigDirector_Fl_Input_::~SwigDirector_Fl_Input_() {
}

void SwigDirector_Fl_Input_::draw() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Input_::handle(int event) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Input_::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Input_::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Input_::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Input_::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Input_::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Input_::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Input_::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Input_::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Input_::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Input_::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Input_::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Input::SwigDirector_Fl_Input(PyObject *self,int arg0,int arg1,int arg2,int arg3,char const *arg4): Fl_Input(arg0, arg1, arg2, arg3, arg4), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Input *)this, this); 
}




SwigDirector_Fl_Input::~SwigDirector_Fl_Input() {
}

void SwigDirector_Fl_Input::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Input::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Input::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Input::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Input::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Input::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Input::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Input::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Input::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Input::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Input::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Input::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Input::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_File_Input::SwigDirector_Fl_File_Input(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_File_Input(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_File_Input *)this, this); 
}




SwigDirector_Fl_File_Input::~SwigDirector_Fl_File_Input() {
}

void SwigDirector_Fl_File_Input::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_File_Input::handle(int event) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_File_Input::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_File_Input::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_File_Input::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_File_Input::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_File_Input::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_File_Input::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_File_Input::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_File_Input::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_File_Input::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_File_Input::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_File_Input::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_File_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Fill_Dial::SwigDirector_Fl_Fill_Dial(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Fill_Dial(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Fill_Dial *)this, this); 
}




SwigDirector_Fl_Fill_Dial::~SwigDirector_Fl_Fill_Dial() {
}

void SwigDirector_Fl_Fill_Dial::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Fill_Dial::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Fill_Dial::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Fill_Dial::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Fill_Dial::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Fill_Dial::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Fill_Dial::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Fill_Dial::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Fill_Dial::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Fill_Dial::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Fill_Dial::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Fill_Dial::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Fill_Dial::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Fill_Dial::format(char *format_string) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)format_string);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Slider::SwigDirector_Fl_Slider(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Slider(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Slider *)this, this); 
}




SwigDirector_Fl_Slider::SwigDirector_Fl_Slider(PyObject *self,uchar t,int X,int Y,int W,int H,char const *L): Fl_Slider(t, X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Slider *)this, this); 
}




SwigDirector_Fl_Slider::~SwigDirector_Fl_Slider() {
}

void SwigDirector_Fl_Slider::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Slider::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Slider::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Slider::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Slider::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Slider::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Slider::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Slider::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Slider::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Slider::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Slider::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Slider::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Slider::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Slider::format(char *format_string) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)format_string);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Fill_Slider::SwigDirector_Fl_Fill_Slider(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Fill_Slider(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Fill_Slider *)this, this); 
}




SwigDirector_Fl_Fill_Slider::~SwigDirector_Fl_Fill_Slider() {
}

void SwigDirector_Fl_Fill_Slider::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Fill_Slider::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Fill_Slider::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Fill_Slider::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Fill_Slider::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Fill_Slider::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Fill_Slider::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Fill_Slider::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Fill_Slider::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Fill_Slider::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Fill_Slider::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Fill_Slider::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Fill_Slider::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Fill_Slider::format(char *format_string) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)format_string);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Flex::SwigDirector_Fl_Flex(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Flex(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Flex *)this, this); 
}




SwigDirector_Fl_Flex::SwigDirector_Fl_Flex(PyObject *self,int direction): Fl_Flex(direction), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Flex *)this, this); 
}




SwigDirector_Fl_Flex::SwigDirector_Fl_Flex(PyObject *self,int w,int h,int direction): Fl_Flex(w, h, direction), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Flex *)this, this); 
}




SwigDirector_Fl_Flex::SwigDirector_Fl_Flex(PyObject *self,int x,int y,int w,int h,int direction): Fl_Flex(x, y, w, h, direction), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Flex *)this, this); 
}




SwigDirector_Fl_Flex::~SwigDirector_Fl_Flex() {
}

void SwigDirector_Fl_Flex::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Flex.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Flex::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Flex.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Flex::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Flex.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Flex::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Flex.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Flex::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Flex.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Flex::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Flex.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Flex::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Flex.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Flex::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Flex.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Flex::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Flex.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Flex::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Flex.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Flex::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Flex.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Flex::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Flex.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Flex::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Flex.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Flex::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Flex::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Flex::on_remove(int arg0) {
  Fl_Flex::on_remove(arg0);
}


int SwigDirector_Fl_Flex::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Flex.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Flex::end() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Flex.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "end";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("end");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Flex::alloc_size(int size) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(size));
  swig_set_inner("alloc_size", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Flex.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "alloc_size";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("alloc_size");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("alloc_size", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Float_Input::SwigDirector_Fl_Float_Input(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Float_Input(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Float_Input *)this, this); 
}




SwigDirector_Fl_Float_Input::~SwigDirector_Fl_Float_Input() {
}

void SwigDirector_Fl_Float_Input::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Float_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Float_Input::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Float_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Float_Input::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Float_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Float_Input::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Float_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Float_Input::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Float_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Float_Input::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Float_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Float_Input::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Float_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Float_Input::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Float_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Float_Input::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Float_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Float_Input::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Float_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Float_Input::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Float_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Float_Input::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Float_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Float_Input::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Float_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Pixmap::SwigDirector_Fl_Pixmap(PyObject *self,char const *const *D): Fl_Pixmap(D), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Pixmap *)this, this); 
}




void SwigDirector_Fl_Pixmap::release() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pixmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "release";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("release");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Shared_Image *SwigDirector_Fl_Pixmap::as_shared_image() {
  Fl_Shared_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pixmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "as_shared_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_shared_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Shared_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Shared_Image *""'");
  }
  c_result = (Fl_Shared_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Shared_Image *) c_result;
}


SwigDirector_Fl_Pixmap::~SwigDirector_Fl_Pixmap() {
}

Fl_Image *SwigDirector_Fl_Pixmap::copy(int W,int H) const {
  Fl_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pixmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "copy";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("copy");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Image *""'");
  }
  c_result = (Fl_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Image *) c_result;
}


void SwigDirector_Fl_Pixmap::color_average(Fl_Color c,float i) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_unsigned_SS_int((unsigned int)(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(i));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pixmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "color_average";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("color_average");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Pixmap::desaturate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pixmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "desaturate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("desaturate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Pixmap::label(Fl_Widget *w) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(w), SWIGTYPE_p_Fl_Widget,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pixmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Pixmap::label(Fl_Menu_Item *m) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(m), SWIGTYPE_p_Fl_Menu_Item,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pixmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Pixmap::draw(int X,int Y,int W,int H,int cx,int cy) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int((int)(cy));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pixmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Pixmap::uncache() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pixmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "uncache";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("uncache");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Pixmap::scale(int width,int height,int proportional,int can_expand) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(width));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(height));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(proportional));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(can_expand));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pixmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Grid::SwigDirector_Fl_Grid(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Grid(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Grid *)this, this); 
}




SwigDirector_Fl_Grid::~SwigDirector_Fl_Grid() {
}

void SwigDirector_Fl_Grid::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Grid::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Grid::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Grid::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Grid::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Grid::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Grid::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Grid::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Grid::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Grid::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Grid::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Grid::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Grid::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Grid::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Grid::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Grid::on_remove(int arg0) {
  Fl_Grid::on_remove(arg0);
}


int SwigDirector_Fl_Grid::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Grid::layout(int rows,int cols,int margin,int gap) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(rows));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(cols));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(margin));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(gap));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "layout";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("layout");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Grid::layout() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "layout";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("layout");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Grid::clear_layout() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 16;
  const char *const swig_method_name = "clear_layout";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("clear_layout");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Grid::draw_grid() {
  swig_set_inner("draw_grid", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 17;
  const char *const swig_method_name = "draw_grid";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw_grid");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw_grid", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Grid::margin(int left,int top,int right,int bottom) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(left));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(top));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(right));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(bottom));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 18;
  const char *const swig_method_name = "margin";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("margin");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Grid::gap(int row_gap,int col_gap) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(row_gap));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(col_gap));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Grid.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 19;
  const char *const swig_method_name = "gap";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("gap");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_GIF_Image::SwigDirector_Fl_GIF_Image(PyObject *self,char const *filename): Fl_GIF_Image(filename), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_GIF_Image *)this, this); 
}




SwigDirector_Fl_GIF_Image::SwigDirector_Fl_GIF_Image(PyObject *self,char const *imagename,unsigned char const *data): Fl_GIF_Image(imagename, data), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_GIF_Image *)this, this); 
}




SwigDirector_Fl_GIF_Image::SwigDirector_Fl_GIF_Image(PyObject *self,char const *imagename,unsigned char const *data,size_t const length): Fl_GIF_Image(imagename, data, length), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_GIF_Image *)this, this); 
}




SwigDirector_Fl_GIF_Image::SwigDirector_Fl_GIF_Image(PyObject *self,char const *filename,bool anim): Fl_GIF_Image(filename, anim), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_GIF_Image *)this, this); 
}




SwigDirector_Fl_GIF_Image::SwigDirector_Fl_GIF_Image(PyObject *self,char const *imagename,unsigned char const *data,size_t const length,bool anim): Fl_GIF_Image(imagename, data, length, anim), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_GIF_Image *)this, this); 
}




SwigDirector_Fl_GIF_Image::SwigDirector_Fl_GIF_Image(PyObject *self): Fl_GIF_Image(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_GIF_Image *)this, this); 
}




void SwigDirector_Fl_GIF_Image::release() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "release";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("release");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Shared_Image *SwigDirector_Fl_GIF_Image::as_shared_image() {
  Fl_Shared_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "as_shared_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_shared_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Shared_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Shared_Image *""'");
  }
  c_result = (Fl_Shared_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Shared_Image *) c_result;
}


SwigDirector_Fl_GIF_Image::~SwigDirector_Fl_GIF_Image() {
}

Fl_Image *SwigDirector_Fl_GIF_Image::copy(int W,int H) const {
  Fl_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "copy";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("copy");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Image *""'");
  }
  c_result = (Fl_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Image *) c_result;
}


void SwigDirector_Fl_GIF_Image::color_average(Fl_Color c,float i) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_unsigned_SS_int((unsigned int)(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(i));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "color_average";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("color_average");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_GIF_Image::desaturate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "desaturate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("desaturate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_GIF_Image::label(Fl_Widget *w) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(w), SWIGTYPE_p_Fl_Widget,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_GIF_Image::label(Fl_Menu_Item *m) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(m), SWIGTYPE_p_Fl_Menu_Item,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_GIF_Image::draw(int X,int Y,int W,int H,int cx,int cy) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int((int)(cy));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_GIF_Image::uncache() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "uncache";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("uncache");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_GIF_Image::scale(int width,int height,int proportional,int can_expand) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(width));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(height));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(proportional));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(can_expand));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Anim_GIF_Image::SwigDirector_Fl_Anim_GIF_Image(PyObject *self,char const *filename,Fl_Widget *canvas,unsigned short flags): Fl_Anim_GIF_Image(filename, canvas, flags), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Anim_GIF_Image *)this, this); 
}




SwigDirector_Fl_Anim_GIF_Image::SwigDirector_Fl_Anim_GIF_Image(PyObject *self,char const *imagename,unsigned char const *data,size_t const length,Fl_Widget *canvas,unsigned short flags): Fl_Anim_GIF_Image(imagename, data, length, canvas, flags), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Anim_GIF_Image *)this, this); 
}




SwigDirector_Fl_Anim_GIF_Image::SwigDirector_Fl_Anim_GIF_Image(PyObject *self): Fl_Anim_GIF_Image(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Anim_GIF_Image *)this, this); 
}




void SwigDirector_Fl_Anim_GIF_Image::release() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Anim_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "release";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("release");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Shared_Image *SwigDirector_Fl_Anim_GIF_Image::as_shared_image() {
  Fl_Shared_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Anim_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "as_shared_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_shared_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Shared_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Shared_Image *""'");
  }
  c_result = (Fl_Shared_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Shared_Image *) c_result;
}


SwigDirector_Fl_Anim_GIF_Image::~SwigDirector_Fl_Anim_GIF_Image() {
}

Fl_Image *SwigDirector_Fl_Anim_GIF_Image::copy(int W,int H) const {
  Fl_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Anim_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "copy";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("copy");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Image *""'");
  }
  c_result = (Fl_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Image *) c_result;
}


void SwigDirector_Fl_Anim_GIF_Image::color_average(Fl_Color c,float i) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_unsigned_SS_int((unsigned int)(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(i));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Anim_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "color_average";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("color_average");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Anim_GIF_Image::desaturate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Anim_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "desaturate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("desaturate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Anim_GIF_Image::label(Fl_Widget *w) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(w), SWIGTYPE_p_Fl_Widget,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Anim_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Anim_GIF_Image::label(Fl_Menu_Item *m) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(m), SWIGTYPE_p_Fl_Menu_Item,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Anim_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Anim_GIF_Image::draw(int x,int y,int w,int h,int cx,int cy) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int((int)(cy));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Anim_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Anim_GIF_Image::uncache() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Anim_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "uncache";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("uncache");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Anim_GIF_Image::scale(int width,int height,int proportional,int can_expand) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(width));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(height));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(proportional));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(can_expand));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Anim_GIF_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_ICO_Image::SwigDirector_Fl_ICO_Image(PyObject *self,char const *filename,int id,unsigned char const *data,size_t const datasize): Fl_ICO_Image(filename, id, data, datasize), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_ICO_Image *)this, this); 
}




void SwigDirector_Fl_ICO_Image::release() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_ICO_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "release";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("release");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Shared_Image *SwigDirector_Fl_ICO_Image::as_shared_image() {
  Fl_Shared_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_ICO_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "as_shared_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_shared_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Shared_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Shared_Image *""'");
  }
  c_result = (Fl_Shared_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Shared_Image *) c_result;
}


SwigDirector_Fl_ICO_Image::~SwigDirector_Fl_ICO_Image() {
}

Fl_Image *SwigDirector_Fl_ICO_Image::copy(int W,int H) const {
  Fl_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_ICO_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "copy";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("copy");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Image *""'");
  }
  c_result = (Fl_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Image *) c_result;
}


void SwigDirector_Fl_ICO_Image::color_average(Fl_Color c,float i) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_unsigned_SS_int((unsigned int)(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(i));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_ICO_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "color_average";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("color_average");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_ICO_Image::desaturate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_ICO_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "desaturate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("desaturate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_ICO_Image::label(Fl_Widget *w) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(w), SWIGTYPE_p_Fl_Widget,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_ICO_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_ICO_Image::label(Fl_Menu_Item *m) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(m), SWIGTYPE_p_Fl_Menu_Item,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_ICO_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_ICO_Image::draw(int X,int Y,int W,int H,int cx,int cy) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int((int)(cy));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_ICO_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_ICO_Image::uncache() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_ICO_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "uncache";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("uncache");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_ICO_Image::scale(int width,int height,int proportional,int can_expand) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(width));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(height));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(proportional));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(can_expand));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_ICO_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_SVG_Image *SwigDirector_Fl_ICO_Image::as_svg_image() {
  Fl_SVG_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_ICO_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_svg_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_svg_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_SVG_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_SVG_Image *""'");
  }
  c_result = (Fl_SVG_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_SVG_Image *) c_result;
}


void SwigDirector_Fl_ICO_Image::normalize() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_ICO_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "normalize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("normalize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Gl_Window::SwigDirector_Fl_Gl_Window(PyObject *self,int W,int H,char const *l): Fl_Gl_Window(W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Gl_Window *)this, this); 
}




SwigDirector_Fl_Gl_Window::SwigDirector_Fl_Gl_Window(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Gl_Window(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Gl_Window *)this, this); 
}




SwigDirector_Fl_Gl_Window::~SwigDirector_Fl_Gl_Window() {
}

void SwigDirector_Fl_Gl_Window::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Gl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Gl_Window::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Gl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Gl_Window::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Gl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Gl_Window::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Gl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Gl_Window::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Gl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Gl_Window::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Gl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Gl_Window::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Gl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Gl_Window::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Gl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Gl_Window::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Gl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Gl_Window::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Gl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Gl_Window::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Gl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Gl_Window::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Gl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Gl_Window::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Gl_Window::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Gl_Window::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Gl_Window::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Gl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Gl_Window::flush() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Gl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "flush";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("flush");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Overlay_Window *SwigDirector_Fl_Gl_Window::as_overlay_window() {
  Fl_Overlay_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Gl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "as_overlay_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_overlay_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Overlay_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Overlay_Window *""'");
  }
  c_result = (Fl_Overlay_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Overlay_Window *) c_result;
}


Fl_Double_Window *SwigDirector_Fl_Gl_Window::as_double_window() {
  Fl_Double_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Gl_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "as_double_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_double_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Double_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Double_Window *""'");
  }
  c_result = (Fl_Double_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Double_Window *) c_result;
}


SwigDirector_Fl_Help_View::SwigDirector_Fl_Help_View(PyObject *self,int xx,int yy,int ww,int hh,char const *l): Fl_Help_View(xx, yy, ww, hh, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Help_View *)this, this); 
}




SwigDirector_Fl_Help_View::~SwigDirector_Fl_Help_View() {
}

void SwigDirector_Fl_Help_View::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Help_View.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Help_View::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Help_View.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Help_View::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Help_View.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Help_View::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Help_View.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Help_View::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Help_View.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Help_View::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Help_View.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Help_View::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Help_View.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Help_View::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Help_View.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Help_View::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Help_View.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Help_View::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Help_View.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Help_View::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Help_View.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Help_View::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Help_View.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Help_View::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Help_View.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Help_View::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Help_View::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Help_View::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Help_View::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Help_View.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Hold_Browser::SwigDirector_Fl_Hold_Browser(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Hold_Browser(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Hold_Browser *)this, this); 
}




SwigDirector_Fl_Hold_Browser::~SwigDirector_Fl_Hold_Browser() {
}

void SwigDirector_Fl_Hold_Browser::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Hold_Browser::handle(int event) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Hold_Browser::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Hold_Browser::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Hold_Browser::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Hold_Browser::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Hold_Browser::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Hold_Browser::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Hold_Browser::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Hold_Browser::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Hold_Browser::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Hold_Browser::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Hold_Browser::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Hold_Browser::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Hold_Browser::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Hold_Browser::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Hold_Browser::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void *SwigDirector_Fl_Hold_Browser::item_first() const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig_set_inner("item_first", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "item_first";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_first");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("item_first", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Hold_Browser::item_next(void *item) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_next", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "item_next";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_next");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_next", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Hold_Browser::item_prev(void *item) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_prev", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 16;
  const char *const swig_method_name = "item_prev";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_prev");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_prev", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Hold_Browser::item_last() const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig_set_inner("item_last", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 17;
  const char *const swig_method_name = "item_last";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_last");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("item_last", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Hold_Browser::item_height(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 18;
  const char *const swig_method_name = "item_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Hold_Browser::item_width(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_width", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 19;
  const char *const swig_method_name = "item_width";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_width");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_width", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Hold_Browser::item_quick_height(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_quick_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 20;
  const char *const swig_method_name = "item_quick_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_quick_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_quick_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Hold_Browser::item_draw(void *item,int X,int Y,int W,int H) const {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(H));
  swig_set_inner("item_draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 21;
  const char *const swig_method_name = "item_draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#endif
  swig_set_inner("item_draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


char const *SwigDirector_Fl_Hold_Browser::item_text(void *item) const {
  char *c_result = 0 ;
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_text", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 22;
  const char *const swig_method_name = "item_text";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_text");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_text", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_AsCharPtrAndSize(result, &buf, NULL, &alloc);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""char const *""'");
  }
  if (alloc == SWIG_NEWOBJ) {
    swig_acquire_ownership_array(buf);
  }
  c_result = (char *)(buf);
  return (char const *) c_result;
}


void SwigDirector_Fl_Hold_Browser::item_swap(void *a,void *b) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(a), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(b), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_swap", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 23;
  const char *const swig_method_name = "item_swap";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_swap");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  swig_set_inner("item_swap", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void *SwigDirector_Fl_Hold_Browser::item_at(int line) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(line));
  swig_set_inner("item_at", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 24;
  const char *const swig_method_name = "item_at";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_at");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_at", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Hold_Browser::full_width() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("full_width", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 25;
  const char *const swig_method_name = "full_width";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("full_width");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("full_width", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Hold_Browser::full_height() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("full_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 26;
  const char *const swig_method_name = "full_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("full_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("full_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Hold_Browser::incr_height() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("incr_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 27;
  const char *const swig_method_name = "incr_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("incr_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("incr_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Hold_Browser::item_select(void *item,int val) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(val));
  swig_set_inner("item_select", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 28;
  const char *const swig_method_name = "item_select";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_select");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  swig_set_inner("item_select", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Hold_Browser::item_selected(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_selected", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hold_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 29;
  const char *const swig_method_name = "item_selected";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_selected");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_selected", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Hor_Fill_Slider::SwigDirector_Fl_Hor_Fill_Slider(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Hor_Fill_Slider(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Hor_Fill_Slider *)this, this); 
}




SwigDirector_Fl_Hor_Fill_Slider::~SwigDirector_Fl_Hor_Fill_Slider() {
}

void SwigDirector_Fl_Hor_Fill_Slider::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Hor_Fill_Slider::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Hor_Fill_Slider::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Hor_Fill_Slider::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Hor_Fill_Slider::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Hor_Fill_Slider::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Hor_Fill_Slider::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Hor_Fill_Slider::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Hor_Fill_Slider::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Hor_Fill_Slider::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Hor_Fill_Slider::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Hor_Fill_Slider::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Hor_Fill_Slider::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Hor_Fill_Slider::format(char *format_string) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)format_string);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Fill_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Hor_Nice_Slider::SwigDirector_Fl_Hor_Nice_Slider(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Hor_Nice_Slider(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Hor_Nice_Slider *)this, this); 
}




SwigDirector_Fl_Hor_Nice_Slider::~SwigDirector_Fl_Hor_Nice_Slider() {
}

void SwigDirector_Fl_Hor_Nice_Slider::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Hor_Nice_Slider::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Hor_Nice_Slider::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Hor_Nice_Slider::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Hor_Nice_Slider::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Hor_Nice_Slider::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Hor_Nice_Slider::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Hor_Nice_Slider::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Hor_Nice_Slider::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Hor_Nice_Slider::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Hor_Nice_Slider::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Hor_Nice_Slider::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Hor_Nice_Slider::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Hor_Nice_Slider::format(char *format_string) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)format_string);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Hor_Slider::SwigDirector_Fl_Hor_Slider(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Hor_Slider(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Hor_Slider *)this, this); 
}




SwigDirector_Fl_Hor_Slider::~SwigDirector_Fl_Hor_Slider() {
}

void SwigDirector_Fl_Hor_Slider::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Hor_Slider::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Hor_Slider::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Hor_Slider::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Hor_Slider::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Hor_Slider::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Hor_Slider::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Hor_Slider::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Hor_Slider::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Hor_Slider::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Hor_Slider::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Hor_Slider::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Hor_Slider::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Hor_Slider::format(char *format_string) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)format_string);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Value_Slider::SwigDirector_Fl_Value_Slider(PyObject *self,int x,int y,int w,int h,char const *l): Fl_Value_Slider(x, y, w, h, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Value_Slider *)this, this); 
}




SwigDirector_Fl_Value_Slider::~SwigDirector_Fl_Value_Slider() {
}

void SwigDirector_Fl_Value_Slider::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Value_Slider::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Value_Slider::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Value_Slider::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Value_Slider::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Value_Slider::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Value_Slider::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Value_Slider::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Value_Slider::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Value_Slider::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Value_Slider::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Value_Slider::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Value_Slider::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Value_Slider::format(char *format_string) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)format_string);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Hor_Value_Slider::SwigDirector_Fl_Hor_Value_Slider(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Hor_Value_Slider(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Hor_Value_Slider *)this, this); 
}




SwigDirector_Fl_Hor_Value_Slider::~SwigDirector_Fl_Hor_Value_Slider() {
}

void SwigDirector_Fl_Hor_Value_Slider::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Hor_Value_Slider::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Hor_Value_Slider::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Hor_Value_Slider::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Hor_Value_Slider::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Hor_Value_Slider::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Hor_Value_Slider::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Hor_Value_Slider::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Hor_Value_Slider::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Hor_Value_Slider::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Hor_Value_Slider::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Hor_Value_Slider::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Hor_Value_Slider::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Hor_Value_Slider::format(char *format_string) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)format_string);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Hor_Value_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Int_Input::SwigDirector_Fl_Int_Input(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Int_Input(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Int_Input *)this, this); 
}




SwigDirector_Fl_Int_Input::~SwigDirector_Fl_Int_Input() {
}

void SwigDirector_Fl_Int_Input::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Int_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Int_Input::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Int_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Int_Input::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Int_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Int_Input::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Int_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Int_Input::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Int_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Int_Input::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Int_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Int_Input::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Int_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Int_Input::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Int_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Int_Input::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Int_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Int_Input::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Int_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Int_Input::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Int_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Int_Input::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Int_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Int_Input::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Int_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Input_Choice::SwigDirector_Fl_Input_Choice(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Input_Choice(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Input_Choice *)this, this); 
}




SwigDirector_Fl_Input_Choice::~SwigDirector_Fl_Input_Choice() {
}

void SwigDirector_Fl_Input_Choice::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Input_Choice::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Input_Choice::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Input_Choice::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Input_Choice::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Input_Choice::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Input_Choice::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Input_Choice::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Input_Choice::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Input_Choice::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Input_Choice::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Input_Choice::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Input_Choice::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Input_Choice::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Input_Choice::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Input_Choice::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Input_Choice::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Input_Choice::inp_x() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("inp_x", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "inp_x";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("inp_x");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("inp_x", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Input_Choice::inp_y() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("inp_y", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "inp_y";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("inp_y");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("inp_y", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Input_Choice::inp_w() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("inp_w", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 16;
  const char *const swig_method_name = "inp_w";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("inp_w");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("inp_w", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Input_Choice::inp_h() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("inp_h", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 17;
  const char *const swig_method_name = "inp_h";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("inp_h");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("inp_h", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Input_Choice::menu_x() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("menu_x", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 18;
  const char *const swig_method_name = "menu_x";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("menu_x");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("menu_x", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Input_Choice::menu_y() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("menu_y", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 19;
  const char *const swig_method_name = "menu_y";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("menu_y");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("menu_y", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Input_Choice::menu_w() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("menu_w", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 20;
  const char *const swig_method_name = "menu_w";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("menu_w");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("menu_w", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Input_Choice::menu_h() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("menu_h", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Input_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 21;
  const char *const swig_method_name = "menu_h";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("menu_h");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("menu_h", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_JPEG_Image::SwigDirector_Fl_JPEG_Image(PyObject *self,char const *filename): Fl_JPEG_Image(filename), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_JPEG_Image *)this, this); 
}




SwigDirector_Fl_JPEG_Image::SwigDirector_Fl_JPEG_Image(PyObject *self,char const *name,unsigned char const *data,int data_length): Fl_JPEG_Image(name, data, data_length), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_JPEG_Image *)this, this); 
}




void SwigDirector_Fl_JPEG_Image::release() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_JPEG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "release";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("release");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Shared_Image *SwigDirector_Fl_JPEG_Image::as_shared_image() {
  Fl_Shared_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_JPEG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "as_shared_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_shared_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Shared_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Shared_Image *""'");
  }
  c_result = (Fl_Shared_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Shared_Image *) c_result;
}


SwigDirector_Fl_JPEG_Image::~SwigDirector_Fl_JPEG_Image() {
}

Fl_Image *SwigDirector_Fl_JPEG_Image::copy(int W,int H) const {
  Fl_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_JPEG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "copy";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("copy");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Image *""'");
  }
  c_result = (Fl_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Image *) c_result;
}


void SwigDirector_Fl_JPEG_Image::color_average(Fl_Color c,float i) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_unsigned_SS_int((unsigned int)(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(i));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_JPEG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "color_average";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("color_average");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_JPEG_Image::desaturate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_JPEG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "desaturate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("desaturate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_JPEG_Image::label(Fl_Widget *w) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(w), SWIGTYPE_p_Fl_Widget,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_JPEG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_JPEG_Image::label(Fl_Menu_Item *m) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(m), SWIGTYPE_p_Fl_Menu_Item,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_JPEG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_JPEG_Image::draw(int X,int Y,int W,int H,int cx,int cy) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int((int)(cy));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_JPEG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_JPEG_Image::uncache() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_JPEG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "uncache";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("uncache");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_JPEG_Image::scale(int width,int height,int proportional,int can_expand) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(width));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(height));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(proportional));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(can_expand));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_JPEG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_SVG_Image *SwigDirector_Fl_JPEG_Image::as_svg_image() {
  Fl_SVG_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_JPEG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_svg_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_svg_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_SVG_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_SVG_Image *""'");
  }
  c_result = (Fl_SVG_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_SVG_Image *) c_result;
}


void SwigDirector_Fl_JPEG_Image::normalize() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_JPEG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "normalize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("normalize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Line_Dial::SwigDirector_Fl_Line_Dial(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Line_Dial(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Line_Dial *)this, this); 
}




SwigDirector_Fl_Line_Dial::~SwigDirector_Fl_Line_Dial() {
}

void SwigDirector_Fl_Line_Dial::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Line_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Line_Dial::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Line_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Line_Dial::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Line_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Line_Dial::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Line_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Line_Dial::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Line_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Line_Dial::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Line_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Line_Dial::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Line_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Line_Dial::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Line_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Line_Dial::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Line_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Line_Dial::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Line_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Line_Dial::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Line_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Line_Dial::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Line_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Line_Dial::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Line_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Line_Dial::format(char *format_string) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)format_string);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Line_Dial.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Menu_Bar::SwigDirector_Fl_Menu_Bar(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Menu_Bar(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Menu_Bar *)this, this); 
}




SwigDirector_Fl_Menu_Bar::~SwigDirector_Fl_Menu_Bar() {
}

void SwigDirector_Fl_Menu_Bar::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Menu_Bar::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Menu_Bar::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Menu_Bar::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Menu_Bar::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Menu_Bar::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Menu_Bar::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Menu_Bar::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Menu_Bar::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Menu_Bar::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Menu_Bar::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Menu_Bar::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Menu_Bar::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


void SwigDirector_Fl_Menu_Bar::update() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "update";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("update");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Menu_Bar::play_menu(Fl_Menu_Item const *item) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_Fl_Menu_Item,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "play_menu";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("play_menu");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Menu_Button::SwigDirector_Fl_Menu_Button(PyObject *self,int arg0,int arg1,int arg2,int arg3,char const *arg4): Fl_Menu_Button(arg0, arg1, arg2, arg3, arg4), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Menu_Button *)this, this); 
}




SwigDirector_Fl_Menu_Button::~SwigDirector_Fl_Menu_Button() {
}

void SwigDirector_Fl_Menu_Button::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Menu_Button::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Menu_Button::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Menu_Button::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Menu_Button::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Menu_Button::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Menu_Button::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Menu_Button::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Menu_Button::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Menu_Button::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Menu_Button::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Menu_Button::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Menu_Button::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Single_Window::SwigDirector_Fl_Single_Window(PyObject *self,int W,int H,char const *l): Fl_Single_Window(W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Single_Window *)this, this); 
}




SwigDirector_Fl_Single_Window::SwigDirector_Fl_Single_Window(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Single_Window(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Single_Window *)this, this); 
}




SwigDirector_Fl_Single_Window::~SwigDirector_Fl_Single_Window() {
}

void SwigDirector_Fl_Single_Window::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Single_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Single_Window::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Single_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Single_Window::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Single_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Single_Window::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Single_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Single_Window::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Single_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Single_Window::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Single_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Single_Window::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Single_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Single_Window::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Single_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Single_Window::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Single_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Single_Window::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Single_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Single_Window::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Single_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Single_Window::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Single_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Single_Window::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Single_Window::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Single_Window::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Single_Window::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Single_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Single_Window::flush() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Single_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "flush";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("flush");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Overlay_Window *SwigDirector_Fl_Single_Window::as_overlay_window() {
  Fl_Overlay_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Single_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "as_overlay_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_overlay_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Overlay_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Overlay_Window *""'");
  }
  c_result = (Fl_Overlay_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Overlay_Window *) c_result;
}


Fl_Double_Window *SwigDirector_Fl_Single_Window::as_double_window() {
  Fl_Double_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Single_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "as_double_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_double_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Double_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Double_Window *""'");
  }
  c_result = (Fl_Double_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Double_Window *) c_result;
}


SwigDirector_Fl_Menu_Window::SwigDirector_Fl_Menu_Window(PyObject *self,int W,int H,char const *l): Fl_Menu_Window(W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Menu_Window *)this, this); 
}




SwigDirector_Fl_Menu_Window::SwigDirector_Fl_Menu_Window(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Menu_Window(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Menu_Window *)this, this); 
}




SwigDirector_Fl_Menu_Window::~SwigDirector_Fl_Menu_Window() {
}

void SwigDirector_Fl_Menu_Window::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Menu_Window::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Menu_Window::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Menu_Window::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Menu_Window::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Menu_Window::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Menu_Window::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Menu_Window::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Menu_Window::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Menu_Window::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Menu_Window::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Menu_Window::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Menu_Window::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Menu_Window::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Menu_Window::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Menu_Window::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Menu_Window::flush() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "flush";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("flush");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Overlay_Window *SwigDirector_Fl_Menu_Window::as_overlay_window() {
  Fl_Overlay_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "as_overlay_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_overlay_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Overlay_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Overlay_Window *""'");
  }
  c_result = (Fl_Overlay_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Overlay_Window *) c_result;
}


Fl_Double_Window *SwigDirector_Fl_Menu_Window::as_double_window() {
  Fl_Double_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Menu_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "as_double_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_double_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Double_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Double_Window *""'");
  }
  c_result = (Fl_Double_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Double_Window *) c_result;
}


SwigDirector_Fl_Multiline_Input::SwigDirector_Fl_Multiline_Input(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Multiline_Input(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Multiline_Input *)this, this); 
}




SwigDirector_Fl_Multiline_Input::~SwigDirector_Fl_Multiline_Input() {
}

void SwigDirector_Fl_Multiline_Input::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Multiline_Input::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Multiline_Input::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Multiline_Input::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Multiline_Input::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Multiline_Input::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Multiline_Input::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Multiline_Input::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Multiline_Input::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Multiline_Input::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Multiline_Input::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Multiline_Input::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Multiline_Input::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Output::SwigDirector_Fl_Output(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Output(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Output *)this, this); 
}




SwigDirector_Fl_Output::~SwigDirector_Fl_Output() {
}

void SwigDirector_Fl_Output::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Output::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Output::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Output::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Output::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Output::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Output::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Output::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Output::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Output::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Output::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Output::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Output::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Multiline_Output::SwigDirector_Fl_Multiline_Output(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Multiline_Output(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Multiline_Output *)this, this); 
}




SwigDirector_Fl_Multiline_Output::~SwigDirector_Fl_Multiline_Output() {
}

void SwigDirector_Fl_Multiline_Output::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Multiline_Output::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Multiline_Output::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Multiline_Output::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Multiline_Output::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Multiline_Output::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Multiline_Output::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Multiline_Output::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Multiline_Output::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Multiline_Output::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Multiline_Output::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Multiline_Output::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Multiline_Output::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multiline_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Multi_Browser::SwigDirector_Fl_Multi_Browser(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Multi_Browser(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Multi_Browser *)this, this); 
}




SwigDirector_Fl_Multi_Browser::~SwigDirector_Fl_Multi_Browser() {
}

void SwigDirector_Fl_Multi_Browser::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Multi_Browser::handle(int event) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Multi_Browser::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Multi_Browser::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Multi_Browser::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Multi_Browser::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Multi_Browser::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Multi_Browser::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Multi_Browser::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Multi_Browser::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Multi_Browser::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Multi_Browser::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Multi_Browser::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Multi_Browser::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Multi_Browser::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Multi_Browser::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Multi_Browser::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void *SwigDirector_Fl_Multi_Browser::item_first() const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig_set_inner("item_first", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "item_first";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_first");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("item_first", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Multi_Browser::item_next(void *item) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_next", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "item_next";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_next");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_next", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Multi_Browser::item_prev(void *item) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_prev", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 16;
  const char *const swig_method_name = "item_prev";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_prev");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_prev", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Multi_Browser::item_last() const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig_set_inner("item_last", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 17;
  const char *const swig_method_name = "item_last";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_last");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("item_last", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Multi_Browser::item_height(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 18;
  const char *const swig_method_name = "item_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Multi_Browser::item_width(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_width", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 19;
  const char *const swig_method_name = "item_width";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_width");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_width", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Multi_Browser::item_quick_height(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_quick_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 20;
  const char *const swig_method_name = "item_quick_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_quick_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_quick_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Multi_Browser::item_draw(void *item,int X,int Y,int W,int H) const {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(H));
  swig_set_inner("item_draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 21;
  const char *const swig_method_name = "item_draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#endif
  swig_set_inner("item_draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


char const *SwigDirector_Fl_Multi_Browser::item_text(void *item) const {
  char *c_result = 0 ;
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_text", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 22;
  const char *const swig_method_name = "item_text";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_text");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_text", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_AsCharPtrAndSize(result, &buf, NULL, &alloc);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""char const *""'");
  }
  if (alloc == SWIG_NEWOBJ) {
    swig_acquire_ownership_array(buf);
  }
  c_result = (char *)(buf);
  return (char const *) c_result;
}


void SwigDirector_Fl_Multi_Browser::item_swap(void *a,void *b) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(a), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(b), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_swap", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 23;
  const char *const swig_method_name = "item_swap";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_swap");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  swig_set_inner("item_swap", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void *SwigDirector_Fl_Multi_Browser::item_at(int line) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(line));
  swig_set_inner("item_at", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 24;
  const char *const swig_method_name = "item_at";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_at");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_at", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Multi_Browser::full_width() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("full_width", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 25;
  const char *const swig_method_name = "full_width";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("full_width");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("full_width", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Multi_Browser::full_height() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("full_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 26;
  const char *const swig_method_name = "full_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("full_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("full_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Multi_Browser::incr_height() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("incr_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 27;
  const char *const swig_method_name = "incr_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("incr_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("incr_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Multi_Browser::item_select(void *item,int val) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(val));
  swig_set_inner("item_select", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 28;
  const char *const swig_method_name = "item_select";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_select");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  swig_set_inner("item_select", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Multi_Browser::item_selected(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_selected", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Multi_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 29;
  const char *const swig_method_name = "item_selected";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_selected");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_selected", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Nice_Slider::SwigDirector_Fl_Nice_Slider(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Nice_Slider(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Nice_Slider *)this, this); 
}




SwigDirector_Fl_Nice_Slider::~SwigDirector_Fl_Nice_Slider() {
}

void SwigDirector_Fl_Nice_Slider::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Nice_Slider::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Nice_Slider::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Nice_Slider::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Nice_Slider::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Nice_Slider::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Nice_Slider::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Nice_Slider::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Nice_Slider::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Nice_Slider::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Nice_Slider::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Nice_Slider::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Nice_Slider::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Nice_Slider::format(char *format_string) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)format_string);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Nice_Slider.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Native_File_Chooser_Driver::SwigDirector_Fl_Native_File_Chooser_Driver(PyObject *self,int arg0): Fl_Native_File_Chooser_Driver(arg0), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Native_File_Chooser_Driver *)this, this); 
}




SwigDirector_Fl_Native_File_Chooser_Driver::~SwigDirector_Fl_Native_File_Chooser_Driver() {
}

void SwigDirector_Fl_Native_File_Chooser_Driver::type(int arg0) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "type";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("type");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Native_File_Chooser_Driver::type() const {
  int c_result = SwigValueInit< int >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "type";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("type");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Native_File_Chooser_Driver::options(int arg0) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "options";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("options");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Native_File_Chooser_Driver::options() const {
  int c_result = SwigValueInit< int >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "options";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("options");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Native_File_Chooser_Driver::count() const {
  int c_result = SwigValueInit< int >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "count";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("count");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


char const *SwigDirector_Fl_Native_File_Chooser_Driver::filename() const {
  char *c_result = 0 ;
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "filename";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("filename");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_AsCharPtrAndSize(result, &buf, NULL, &alloc);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""char const *""'");
  }
  if (alloc == SWIG_NEWOBJ) {
    swig_acquire_ownership_array(buf);
  }
  c_result = (char *)(buf);
  return (char const *) c_result;
}


char const *SwigDirector_Fl_Native_File_Chooser_Driver::filename(int arg0) const {
  char *c_result = 0 ;
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "filename";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("filename");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_AsCharPtrAndSize(result, &buf, NULL, &alloc);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""char const *""'");
  }
  if (alloc == SWIG_NEWOBJ) {
    swig_acquire_ownership_array(buf);
  }
  c_result = (char *)(buf);
  return (char const *) c_result;
}


void SwigDirector_Fl_Native_File_Chooser_Driver::directory(char const *arg0) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)arg0);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "directory";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("directory");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


char const *SwigDirector_Fl_Native_File_Chooser_Driver::directory() const {
  char *c_result = 0 ;
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "directory";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("directory");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_AsCharPtrAndSize(result, &buf, NULL, &alloc);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""char const *""'");
  }
  if (alloc == SWIG_NEWOBJ) {
    swig_acquire_ownership_array(buf);
  }
  c_result = (char *)(buf);
  return (char const *) c_result;
}


void SwigDirector_Fl_Native_File_Chooser_Driver::title(char const *arg0) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)arg0);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "title";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("title");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


char const *SwigDirector_Fl_Native_File_Chooser_Driver::title() const {
  char *c_result = 0 ;
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "title";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("title");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_AsCharPtrAndSize(result, &buf, NULL, &alloc);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""char const *""'");
  }
  if (alloc == SWIG_NEWOBJ) {
    swig_acquire_ownership_array(buf);
  }
  c_result = (char *)(buf);
  return (char const *) c_result;
}


char const *SwigDirector_Fl_Native_File_Chooser_Driver::filter() const {
  char *c_result = 0 ;
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "filter";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("filter");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_AsCharPtrAndSize(result, &buf, NULL, &alloc);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""char const *""'");
  }
  if (alloc == SWIG_NEWOBJ) {
    swig_acquire_ownership_array(buf);
  }
  c_result = (char *)(buf);
  return (char const *) c_result;
}


void SwigDirector_Fl_Native_File_Chooser_Driver::filter(char const *arg0) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)arg0);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "filter";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("filter");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Native_File_Chooser_Driver::filters() const {
  int c_result = SwigValueInit< int >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "filters";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("filters");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Native_File_Chooser_Driver::filter_value(int arg0) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "filter_value";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("filter_value");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Native_File_Chooser_Driver::filter_value() const {
  int c_result = SwigValueInit< int >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "filter_value";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("filter_value");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Native_File_Chooser_Driver::preset_file(char const *arg0) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)arg0);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 16;
  const char *const swig_method_name = "preset_file";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("preset_file");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


char const *SwigDirector_Fl_Native_File_Chooser_Driver::preset_file() const {
  char *c_result = 0 ;
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 17;
  const char *const swig_method_name = "preset_file";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("preset_file");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_AsCharPtrAndSize(result, &buf, NULL, &alloc);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""char const *""'");
  }
  if (alloc == SWIG_NEWOBJ) {
    swig_acquire_ownership_array(buf);
  }
  c_result = (char *)(buf);
  return (char const *) c_result;
}


char const *SwigDirector_Fl_Native_File_Chooser_Driver::errmsg() const {
  char *c_result = 0 ;
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 18;
  const char *const swig_method_name = "errmsg";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("errmsg");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_AsCharPtrAndSize(result, &buf, NULL, &alloc);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""char const *""'");
  }
  if (alloc == SWIG_NEWOBJ) {
    swig_acquire_ownership_array(buf);
  }
  c_result = (char *)(buf);
  return (char const *) c_result;
}


int SwigDirector_Fl_Native_File_Chooser_Driver::show() {
  int c_result = SwigValueInit< int >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Native_File_Chooser_Driver.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 19;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Overlay_Window::SwigDirector_Fl_Overlay_Window(PyObject *self,int W,int H,char const *l): Fl_Overlay_Window(W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Overlay_Window *)this, this); 
}




SwigDirector_Fl_Overlay_Window::SwigDirector_Fl_Overlay_Window(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Overlay_Window(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Overlay_Window *)this, this); 
}




SwigDirector_Fl_Overlay_Window::~SwigDirector_Fl_Overlay_Window() {
}

void SwigDirector_Fl_Overlay_Window::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Overlay_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Overlay_Window::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Overlay_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Overlay_Window::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Overlay_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Overlay_Window::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Overlay_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Overlay_Window::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Overlay_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Overlay_Window::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Overlay_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Overlay_Window::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Overlay_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Overlay_Window::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Overlay_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Overlay_Window::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Overlay_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Overlay_Window::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Overlay_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Overlay_Window::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Overlay_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Overlay_Window::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Overlay_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Overlay_Window::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Overlay_Window::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Overlay_Window::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Overlay_Window::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Overlay_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Overlay_Window::flush() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Overlay_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "flush";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("flush");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Overlay_Window *SwigDirector_Fl_Overlay_Window::as_overlay_window() {
  Fl_Overlay_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Overlay_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "as_overlay_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_overlay_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Overlay_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Overlay_Window *""'");
  }
  c_result = (Fl_Overlay_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Overlay_Window *) c_result;
}


Fl_Double_Window *SwigDirector_Fl_Overlay_Window::as_double_window() {
  Fl_Double_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Overlay_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "as_double_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_double_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Double_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Double_Window *""'");
  }
  c_result = (Fl_Double_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Double_Window *) c_result;
}


void SwigDirector_Fl_Overlay_Window::draw_overlay() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Overlay_Window.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 16;
  const char *const swig_method_name = "draw_overlay";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw_overlay");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Pack::SwigDirector_Fl_Pack(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Pack(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Pack *)this, this); 
}




SwigDirector_Fl_Pack::~SwigDirector_Fl_Pack() {
}

void SwigDirector_Fl_Pack::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pack.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Pack::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pack.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Pack::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pack.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Pack::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pack.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Pack::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pack.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Pack::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pack.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Pack::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pack.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Pack::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pack.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Pack::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pack.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Pack::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pack.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Pack::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pack.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Pack::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pack.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Pack::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pack.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Pack::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Pack::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Pack::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Pack::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Pack.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_PNG_Image::SwigDirector_Fl_PNG_Image(PyObject *self,char const *filename): Fl_PNG_Image(filename), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_PNG_Image *)this, this); 
}




SwigDirector_Fl_PNG_Image::SwigDirector_Fl_PNG_Image(PyObject *self,char const *name_png,unsigned char const *buffer,int datasize): Fl_PNG_Image(name_png, buffer, datasize), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_PNG_Image *)this, this); 
}




void SwigDirector_Fl_PNG_Image::release() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "release";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("release");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Shared_Image *SwigDirector_Fl_PNG_Image::as_shared_image() {
  Fl_Shared_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "as_shared_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_shared_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Shared_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Shared_Image *""'");
  }
  c_result = (Fl_Shared_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Shared_Image *) c_result;
}


SwigDirector_Fl_PNG_Image::~SwigDirector_Fl_PNG_Image() {
}

Fl_Image *SwigDirector_Fl_PNG_Image::copy(int W,int H) const {
  Fl_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "copy";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("copy");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Image *""'");
  }
  c_result = (Fl_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Image *) c_result;
}


void SwigDirector_Fl_PNG_Image::color_average(Fl_Color c,float i) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_unsigned_SS_int((unsigned int)(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(i));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "color_average";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("color_average");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PNG_Image::desaturate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "desaturate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("desaturate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PNG_Image::label(Fl_Widget *w) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(w), SWIGTYPE_p_Fl_Widget,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PNG_Image::label(Fl_Menu_Item *m) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(m), SWIGTYPE_p_Fl_Menu_Item,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PNG_Image::draw(int X,int Y,int W,int H,int cx,int cy) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int((int)(cy));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PNG_Image::uncache() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "uncache";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("uncache");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PNG_Image::scale(int width,int height,int proportional,int can_expand) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(width));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(height));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(proportional));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(can_expand));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_SVG_Image *SwigDirector_Fl_PNG_Image::as_svg_image() {
  Fl_SVG_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_svg_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_svg_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_SVG_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_SVG_Image *""'");
  }
  c_result = (Fl_SVG_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_SVG_Image *) c_result;
}


void SwigDirector_Fl_PNG_Image::normalize() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "normalize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("normalize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_PNM_Image::SwigDirector_Fl_PNM_Image(PyObject *self,char const *filename): Fl_PNM_Image(filename), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_PNM_Image *)this, this); 
}




void SwigDirector_Fl_PNM_Image::release() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "release";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("release");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Shared_Image *SwigDirector_Fl_PNM_Image::as_shared_image() {
  Fl_Shared_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "as_shared_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_shared_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Shared_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Shared_Image *""'");
  }
  c_result = (Fl_Shared_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Shared_Image *) c_result;
}


SwigDirector_Fl_PNM_Image::~SwigDirector_Fl_PNM_Image() {
}

Fl_Image *SwigDirector_Fl_PNM_Image::copy(int W,int H) const {
  Fl_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "copy";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("copy");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Image *""'");
  }
  c_result = (Fl_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Image *) c_result;
}


void SwigDirector_Fl_PNM_Image::color_average(Fl_Color c,float i) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_unsigned_SS_int((unsigned int)(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(i));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "color_average";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("color_average");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PNM_Image::desaturate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "desaturate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("desaturate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PNM_Image::label(Fl_Widget *w) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(w), SWIGTYPE_p_Fl_Widget,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PNM_Image::label(Fl_Menu_Item *m) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(m), SWIGTYPE_p_Fl_Menu_Item,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PNM_Image::draw(int X,int Y,int W,int H,int cx,int cy) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int((int)(cy));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PNM_Image::uncache() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "uncache";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("uncache");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PNM_Image::scale(int width,int height,int proportional,int can_expand) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(width));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(height));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(proportional));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(can_expand));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_SVG_Image *SwigDirector_Fl_PNM_Image::as_svg_image() {
  Fl_SVG_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_svg_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_svg_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_SVG_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_SVG_Image *""'");
  }
  c_result = (Fl_SVG_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_SVG_Image *) c_result;
}


void SwigDirector_Fl_PNM_Image::normalize() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PNM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "normalize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("normalize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Positioner::SwigDirector_Fl_Positioner(PyObject *self,int x,int y,int w,int h,char const *l): Fl_Positioner(x, y, w, h, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Positioner *)this, this); 
}




SwigDirector_Fl_Positioner::~SwigDirector_Fl_Positioner() {
}

void SwigDirector_Fl_Positioner::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Positioner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Positioner::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Positioner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Positioner::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Positioner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Positioner::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Positioner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Positioner::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Positioner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Positioner::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Positioner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Positioner::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Positioner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Positioner::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Positioner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Positioner::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Positioner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Positioner::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Positioner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Positioner::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Positioner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Positioner::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Positioner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Positioner::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Positioner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Progress::SwigDirector_Fl_Progress(PyObject *self,int x,int y,int w,int h,char const *l): Fl_Progress(x, y, w, h, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Progress *)this, this); 
}




SwigDirector_Fl_Progress::~SwigDirector_Fl_Progress() {
}

void SwigDirector_Fl_Progress::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Progress.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Progress::handle(int event) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Progress.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Progress::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Progress.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Progress::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Progress.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Progress::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Progress.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Progress::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Progress.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Progress::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Progress.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Progress::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Progress.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Progress::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Progress.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Progress::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Progress.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Progress::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Progress.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Progress::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Progress.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Progress::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Progress.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Radio_Button::SwigDirector_Fl_Radio_Button(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Radio_Button(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Radio_Button *)this, this); 
}




SwigDirector_Fl_Radio_Button::~SwigDirector_Fl_Radio_Button() {
}

void SwigDirector_Fl_Radio_Button::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Radio_Button::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Radio_Button::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Radio_Button::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Radio_Button::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Radio_Button::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Radio_Button::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Radio_Button::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Radio_Button::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Radio_Button::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Radio_Button::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Radio_Button::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Radio_Button::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Radio_Light_Button::SwigDirector_Fl_Radio_Light_Button(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Radio_Light_Button(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Radio_Light_Button *)this, this); 
}




SwigDirector_Fl_Radio_Light_Button::~SwigDirector_Fl_Radio_Light_Button() {
}

void SwigDirector_Fl_Radio_Light_Button::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Radio_Light_Button::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Radio_Light_Button::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Radio_Light_Button::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Radio_Light_Button::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Radio_Light_Button::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Radio_Light_Button::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Radio_Light_Button::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Radio_Light_Button::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Radio_Light_Button::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Radio_Light_Button::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Radio_Light_Button::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Radio_Light_Button::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Light_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Round_Button::SwigDirector_Fl_Round_Button(PyObject *self,int x,int y,int w,int h,char const *l): Fl_Round_Button(x, y, w, h, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Round_Button *)this, this); 
}




SwigDirector_Fl_Round_Button::~SwigDirector_Fl_Round_Button() {
}

void SwigDirector_Fl_Round_Button::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Round_Button::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Round_Button::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Round_Button::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Round_Button::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Round_Button::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Round_Button::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Round_Button::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Round_Button::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Round_Button::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Round_Button::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Round_Button::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Round_Button::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Radio_Round_Button::SwigDirector_Fl_Radio_Round_Button(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Radio_Round_Button(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Radio_Round_Button *)this, this); 
}




SwigDirector_Fl_Radio_Round_Button::~SwigDirector_Fl_Radio_Round_Button() {
}

void SwigDirector_Fl_Radio_Round_Button::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Radio_Round_Button::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Radio_Round_Button::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Radio_Round_Button::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Radio_Round_Button::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Radio_Round_Button::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Radio_Round_Button::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Radio_Round_Button::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Radio_Round_Button::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Radio_Round_Button::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Radio_Round_Button::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Radio_Round_Button::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Radio_Round_Button::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Radio_Round_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Repeat_Button::SwigDirector_Fl_Repeat_Button(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Repeat_Button(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Repeat_Button *)this, this); 
}




SwigDirector_Fl_Repeat_Button::~SwigDirector_Fl_Repeat_Button() {
}

void SwigDirector_Fl_Repeat_Button::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Repeat_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Repeat_Button::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Repeat_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Repeat_Button::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Repeat_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Repeat_Button::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Repeat_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Repeat_Button::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Repeat_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Repeat_Button::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Repeat_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Repeat_Button::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Repeat_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Repeat_Button::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Repeat_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Repeat_Button::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Repeat_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Repeat_Button::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Repeat_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Repeat_Button::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Repeat_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Repeat_Button::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Repeat_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Repeat_Button::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Repeat_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Return_Button::SwigDirector_Fl_Return_Button(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Return_Button(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Return_Button *)this, this); 
}




SwigDirector_Fl_Return_Button::~SwigDirector_Fl_Return_Button() {
}

void SwigDirector_Fl_Return_Button::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Return_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Return_Button::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Return_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Return_Button::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Return_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Return_Button::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Return_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Return_Button::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Return_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Return_Button::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Return_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Return_Button::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Return_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Return_Button::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Return_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Return_Button::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Return_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Return_Button::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Return_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Return_Button::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Return_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Return_Button::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Return_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Return_Button::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Return_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_SVG_Image::SwigDirector_Fl_SVG_Image(PyObject *self,char const *filename): Fl_SVG_Image(filename), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_SVG_Image *)this, this); 
}




SwigDirector_Fl_SVG_Image::SwigDirector_Fl_SVG_Image(PyObject *self,char const *sharedname,char const *svg_data): Fl_SVG_Image(sharedname, svg_data), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_SVG_Image *)this, this); 
}




SwigDirector_Fl_SVG_Image::SwigDirector_Fl_SVG_Image(PyObject *self,char const *sharedname,unsigned char const *svg_data,size_t length): Fl_SVG_Image(sharedname, svg_data, length), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_SVG_Image *)this, this); 
}




void SwigDirector_Fl_SVG_Image::release() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_SVG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "release";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("release");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Shared_Image *SwigDirector_Fl_SVG_Image::as_shared_image() {
  Fl_Shared_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_SVG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "as_shared_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_shared_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Shared_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Shared_Image *""'");
  }
  c_result = (Fl_Shared_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Shared_Image *) c_result;
}


SwigDirector_Fl_SVG_Image::~SwigDirector_Fl_SVG_Image() {
}

Fl_Image *SwigDirector_Fl_SVG_Image::copy(int W,int H) const {
  Fl_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_SVG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "copy";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("copy");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Image *""'");
  }
  c_result = (Fl_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Image *) c_result;
}


void SwigDirector_Fl_SVG_Image::color_average(Fl_Color c,float i) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_unsigned_SS_int((unsigned int)(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(i));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_SVG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "color_average";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("color_average");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_SVG_Image::desaturate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_SVG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "desaturate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("desaturate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_SVG_Image::label(Fl_Widget *w) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(w), SWIGTYPE_p_Fl_Widget,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_SVG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_SVG_Image::label(Fl_Menu_Item *m) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(m), SWIGTYPE_p_Fl_Menu_Item,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_SVG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_SVG_Image::draw(int X,int Y,int W,int H,int cx,int cy) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int((int)(cy));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_SVG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_SVG_Image::uncache() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_SVG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "uncache";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("uncache");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_SVG_Image::scale(int width,int height,int proportional,int can_expand) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(width));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(height));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(proportional));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(can_expand));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_SVG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_SVG_Image *SwigDirector_Fl_SVG_Image::as_svg_image() {
  Fl_SVG_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_SVG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_svg_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_svg_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_SVG_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_SVG_Image *""'");
  }
  c_result = (Fl_SVG_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_SVG_Image *) c_result;
}


void SwigDirector_Fl_SVG_Image::normalize() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_SVG_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "normalize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("normalize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Roller::SwigDirector_Fl_Roller(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Roller(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Roller *)this, this); 
}




SwigDirector_Fl_Roller::~SwigDirector_Fl_Roller() {
}

void SwigDirector_Fl_Roller::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Roller.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Roller::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Roller.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Roller::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Roller.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Roller::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Roller.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Roller::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Roller.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Roller::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Roller.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Roller::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Roller.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Roller::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Roller.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Roller::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Roller.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Roller::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Roller.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Roller::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Roller.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Roller::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Roller.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Roller::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Roller.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Roller::format(char *format_string) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)format_string);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Roller.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Round_Clock::SwigDirector_Fl_Round_Clock(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Round_Clock(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Round_Clock *)this, this); 
}




SwigDirector_Fl_Round_Clock::~SwigDirector_Fl_Round_Clock() {
}

void SwigDirector_Fl_Round_Clock::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Round_Clock::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Round_Clock::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Round_Clock::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Round_Clock::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Round_Clock::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Round_Clock::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Round_Clock::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Round_Clock::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Round_Clock::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Round_Clock::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Round_Clock::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Round_Clock::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Round_Clock.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Scroll::SwigDirector_Fl_Scroll(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Scroll(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Scroll *)this, this); 
}




SwigDirector_Fl_Scroll::~SwigDirector_Fl_Scroll() {
}

void SwigDirector_Fl_Scroll::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scroll.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Scroll::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scroll.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Scroll::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scroll.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Scroll::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scroll.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Scroll::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scroll.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Scroll::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scroll.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Scroll::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scroll.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Scroll::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scroll.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Scroll::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scroll.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Scroll::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scroll.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Scroll::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scroll.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Scroll::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scroll.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Scroll::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scroll.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Scroll::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Scroll::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Scroll::on_move(int arg0,int arg1) {
  return Fl_Scroll::on_move(arg0,arg1);
}


void SwigDirector_Fl_Scroll::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Scroll::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scroll.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Scheme_Choice::SwigDirector_Fl_Scheme_Choice(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Scheme_Choice(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Scheme_Choice *)this, this); 
}




SwigDirector_Fl_Scheme_Choice::~SwigDirector_Fl_Scheme_Choice() {
}

void SwigDirector_Fl_Scheme_Choice::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scheme_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Scheme_Choice::handle(int event) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scheme_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Scheme_Choice::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scheme_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Scheme_Choice::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scheme_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Scheme_Choice::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scheme_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Scheme_Choice::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scheme_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Scheme_Choice::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scheme_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Scheme_Choice::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scheme_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Scheme_Choice::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scheme_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Scheme_Choice::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scheme_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Scheme_Choice::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scheme_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Scheme_Choice::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scheme_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Scheme_Choice::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scheme_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


void SwigDirector_Fl_Scheme_Choice::init_value() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scheme_Choice.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "init_value";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("init_value");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Scrollbar::SwigDirector_Fl_Scrollbar(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Scrollbar(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Scrollbar *)this, this); 
}




SwigDirector_Fl_Scrollbar::~SwigDirector_Fl_Scrollbar() {
}

void SwigDirector_Fl_Scrollbar::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scrollbar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Scrollbar::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scrollbar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Scrollbar::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scrollbar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Scrollbar::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scrollbar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Scrollbar::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scrollbar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Scrollbar::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scrollbar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Scrollbar::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scrollbar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Scrollbar::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scrollbar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Scrollbar::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scrollbar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Scrollbar::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scrollbar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Scrollbar::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scrollbar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Scrollbar::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scrollbar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Scrollbar::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scrollbar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Scrollbar::format(char *format_string) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)format_string);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Scrollbar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Secret_Input::SwigDirector_Fl_Secret_Input(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Secret_Input(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Secret_Input *)this, this); 
}




SwigDirector_Fl_Secret_Input::~SwigDirector_Fl_Secret_Input() {
}

void SwigDirector_Fl_Secret_Input::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Secret_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Secret_Input::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Secret_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Secret_Input::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Secret_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Secret_Input::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Secret_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Secret_Input::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Secret_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Secret_Input::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Secret_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Secret_Input::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Secret_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Secret_Input::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Secret_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Secret_Input::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Secret_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Secret_Input::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Secret_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Secret_Input::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Secret_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Secret_Input::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Secret_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Secret_Input::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Secret_Input.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Select_Browser::SwigDirector_Fl_Select_Browser(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Select_Browser(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Select_Browser *)this, this); 
}




SwigDirector_Fl_Select_Browser::~SwigDirector_Fl_Select_Browser() {
}

void SwigDirector_Fl_Select_Browser::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Select_Browser::handle(int event) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Select_Browser::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Select_Browser::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Select_Browser::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Select_Browser::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Select_Browser::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Select_Browser::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Select_Browser::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Select_Browser::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Select_Browser::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Select_Browser::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Select_Browser::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Select_Browser::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Select_Browser::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Select_Browser::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Select_Browser::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void *SwigDirector_Fl_Select_Browser::item_first() const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig_set_inner("item_first", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "item_first";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_first");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("item_first", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Select_Browser::item_next(void *item) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_next", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "item_next";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_next");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_next", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Select_Browser::item_prev(void *item) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_prev", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 16;
  const char *const swig_method_name = "item_prev";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_prev");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_prev", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Select_Browser::item_last() const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig_set_inner("item_last", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 17;
  const char *const swig_method_name = "item_last";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_last");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("item_last", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Select_Browser::item_height(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 18;
  const char *const swig_method_name = "item_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Select_Browser::item_width(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_width", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 19;
  const char *const swig_method_name = "item_width";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_width");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_width", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Select_Browser::item_quick_height(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_quick_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 20;
  const char *const swig_method_name = "item_quick_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_quick_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_quick_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Select_Browser::item_draw(void *item,int X,int Y,int W,int H) const {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(H));
  swig_set_inner("item_draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 21;
  const char *const swig_method_name = "item_draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL);
#endif
  swig_set_inner("item_draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


char const *SwigDirector_Fl_Select_Browser::item_text(void *item) const {
  char *c_result = 0 ;
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_text", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 22;
  const char *const swig_method_name = "item_text";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_text");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_text", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_AsCharPtrAndSize(result, &buf, NULL, &alloc);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""char const *""'");
  }
  if (alloc == SWIG_NEWOBJ) {
    swig_acquire_ownership_array(buf);
  }
  c_result = (char *)(buf);
  return (char const *) c_result;
}


void SwigDirector_Fl_Select_Browser::item_swap(void *a,void *b) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(a), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(b), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_swap", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 23;
  const char *const swig_method_name = "item_swap";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_swap");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  swig_set_inner("item_swap", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void *SwigDirector_Fl_Select_Browser::item_at(int line) const {
  void *c_result = 0 ;
  void *argp ;
  int res ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(line));
  swig_set_inner("item_at", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 24;
  const char *const swig_method_name = "item_at";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_at");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_at", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_ConvertPtr(result, &argp, 0, 0);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""void *""'");
  }
  c_result = (void *)(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Select_Browser::full_width() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("full_width", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 25;
  const char *const swig_method_name = "full_width";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("full_width");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("full_width", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Select_Browser::full_height() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("full_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 26;
  const char *const swig_method_name = "full_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("full_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("full_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Select_Browser::incr_height() const {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("incr_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 27;
  const char *const swig_method_name = "incr_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("incr_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("incr_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Select_Browser::item_select(void *item,int val) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(val));
  swig_set_inner("item_select", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 28;
  const char *const swig_method_name = "item_select";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_select");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  swig_set_inner("item_select", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Select_Browser::item_selected(void *item) const {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(item), SWIGTYPE_p_void,  0 );
  swig_set_inner("item_selected", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Select_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 29;
  const char *const swig_method_name = "item_selected";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("item_selected");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("item_selected", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Shared_Image::SwigDirector_Fl_Shared_Image(PyObject *self): Fl_Shared_Image(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Shared_Image *)this, this); 
}




SwigDirector_Fl_Shared_Image::SwigDirector_Fl_Shared_Image(PyObject *self,char const *n,Fl_Image *img): Fl_Shared_Image(n, img), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Shared_Image *)this, this); 
}




void SwigDirector_Fl_Shared_Image::release() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shared_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "release";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("release");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Shared_Image *SwigDirector_Fl_Shared_Image::as_shared_image() {
  Fl_Shared_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shared_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "as_shared_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_shared_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Shared_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Shared_Image *""'");
  }
  c_result = (Fl_Shared_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Shared_Image *) c_result;
}


SwigDirector_Fl_Shared_Image::~SwigDirector_Fl_Shared_Image() {
}

Fl_Image *SwigDirector_Fl_Shared_Image::copy(int W,int H) const {
  Fl_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shared_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "copy";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("copy");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Image *""'");
  }
  c_result = (Fl_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Image *) c_result;
}


void SwigDirector_Fl_Shared_Image::color_average(Fl_Color c,float i) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_unsigned_SS_int((unsigned int)(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(i));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shared_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "color_average";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("color_average");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Shared_Image::desaturate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shared_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "desaturate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("desaturate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Shared_Image::label(Fl_Widget *w) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(w), SWIGTYPE_p_Fl_Widget,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shared_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Shared_Image::label(Fl_Menu_Item *m) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(m), SWIGTYPE_p_Fl_Menu_Item,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shared_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Shared_Image::draw(int X,int Y,int W,int H,int cx,int cy) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int((int)(cy));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shared_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Shared_Image::uncache() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shared_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "uncache";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("uncache");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Shared_Image::scale(int width,int height,int proportional,int can_expand) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(width));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(height));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(proportional));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(can_expand));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shared_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Shared_Image::reload() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Shared_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "reload";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("reload");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Spinner::SwigDirector_Fl_Spinner(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Spinner(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Spinner *)this, this); 
}




SwigDirector_Fl_Spinner::~SwigDirector_Fl_Spinner() {
}

void SwigDirector_Fl_Spinner::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Spinner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Spinner::handle(int event) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Spinner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Spinner::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Spinner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Spinner::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Spinner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Spinner::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Spinner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Spinner::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Spinner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Spinner::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Spinner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Spinner::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Spinner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Spinner::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Spinner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Spinner::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Spinner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Spinner::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Spinner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Spinner::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Spinner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Spinner::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Spinner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Spinner::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Spinner::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Spinner::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Spinner::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Spinner.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Simple_Counter::SwigDirector_Fl_Simple_Counter(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Simple_Counter(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Simple_Counter *)this, this); 
}




SwigDirector_Fl_Simple_Counter::~SwigDirector_Fl_Simple_Counter() {
}

void SwigDirector_Fl_Simple_Counter::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Simple_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Simple_Counter::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Simple_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Simple_Counter::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Simple_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Simple_Counter::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Simple_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Simple_Counter::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Simple_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Simple_Counter::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Simple_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Simple_Counter::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Simple_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Simple_Counter::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Simple_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Simple_Counter::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Simple_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Simple_Counter::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Simple_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Simple_Counter::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Simple_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Simple_Counter::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Simple_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Simple_Counter::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Simple_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Simple_Counter::format(char *format_string) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)format_string);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Simple_Counter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Sys_Menu_Bar::SwigDirector_Fl_Sys_Menu_Bar(PyObject *self,int x,int y,int w,int h,char const *l): Fl_Sys_Menu_Bar(x, y, w, h, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Sys_Menu_Bar *)this, this); 
}




SwigDirector_Fl_Sys_Menu_Bar::~SwigDirector_Fl_Sys_Menu_Bar() {
}

void SwigDirector_Fl_Sys_Menu_Bar::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Sys_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Sys_Menu_Bar::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Sys_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Sys_Menu_Bar::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Sys_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Sys_Menu_Bar::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Sys_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Sys_Menu_Bar::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Sys_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Sys_Menu_Bar::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Sys_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Sys_Menu_Bar::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Sys_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Sys_Menu_Bar::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Sys_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Sys_Menu_Bar::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Sys_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Sys_Menu_Bar::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Sys_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Sys_Menu_Bar::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Sys_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Sys_Menu_Bar::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Sys_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Sys_Menu_Bar::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Sys_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


void SwigDirector_Fl_Sys_Menu_Bar::update() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Sys_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "update";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("update");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Sys_Menu_Bar::play_menu(Fl_Menu_Item const *arg0) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(arg0), SWIGTYPE_p_Fl_Menu_Item,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Sys_Menu_Bar.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "play_menu";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("play_menu");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Table::SwigDirector_Fl_Table(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Table(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Table *)this, this); 
}




SwigDirector_Fl_Table::~SwigDirector_Fl_Table() {
}

void SwigDirector_Fl_Table::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Table::handle(int e) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(e));
  swig_set_inner("handle", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("handle", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Table::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Table::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Table::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Table::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Table::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Table::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Table::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Table::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Table::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Table::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Table::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Table::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Table::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Table::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Table::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Table::draw_cell(Fl_Table::TableContext context,int R,int C,int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(context));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(R));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(C));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj6;
  obj6 = SWIG_From_int((int)(H));
  swig_set_inner("draw_cell", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "draw_cell";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw_cell");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6, NULL);
#endif
  swig_set_inner("draw_cell", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Table::clear() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "clear";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("clear");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Table::rows(int val) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(val));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 16;
  const char *const swig_method_name = "rows";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("rows");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Table::cols(int val) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(val));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 17;
  const char *const swig_method_name = "cols";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("cols");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Table_Row::SwigDirector_Fl_Table_Row(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Table_Row(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Table_Row *)this, this); 
}




SwigDirector_Fl_Table_Row::~SwigDirector_Fl_Table_Row() {
}

void SwigDirector_Fl_Table_Row::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table_Row.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Table_Row::handle(int event) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event));
  swig_set_inner("handle", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table_Row.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  swig_set_inner("handle", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Table_Row::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table_Row.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Table_Row::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table_Row.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Table_Row::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table_Row.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Table_Row::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table_Row.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Table_Row::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table_Row.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Table_Row::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table_Row.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Table_Row::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table_Row.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Table_Row::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table_Row.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Table_Row::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table_Row.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Table_Row::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table_Row.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Table_Row::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table_Row.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Table_Row::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Table_Row::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Table_Row::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Table_Row::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table_Row.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Table_Row::draw_cell(Fl_Table::TableContext context,int R,int C,int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(context));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(R));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(C));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj6;
  obj6 = SWIG_From_int((int)(H));
  swig_set_inner("draw_cell", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table_Row.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "draw_cell";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw_cell");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6, NULL);
#endif
  swig_set_inner("draw_cell", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Table_Row::clear() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table_Row.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "clear";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("clear");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Table_Row::rows(int val) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(val));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table_Row.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 16;
  const char *const swig_method_name = "rows";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("rows");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Table_Row::cols(int val) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(val));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Table_Row.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 17;
  const char *const swig_method_name = "cols";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("cols");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Tabs::SwigDirector_Fl_Tabs(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Tabs(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Tabs *)this, this); 
}




SwigDirector_Fl_Tabs::~SwigDirector_Fl_Tabs() {
}

void SwigDirector_Fl_Tabs::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Tabs::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Tabs::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Tabs::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Tabs::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Tabs::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Tabs::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Tabs::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Tabs::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Tabs::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Tabs::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Tabs::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Tabs::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Tabs::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Tabs::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Tabs::on_move(int arg0,int arg1) {
  return Fl_Tabs::on_move(arg0,arg1);
}


void SwigDirector_Fl_Tabs::on_remove(int arg0) {
  Fl_Tabs::on_remove(arg0);
}


int SwigDirector_Fl_Tabs::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Tabs::redraw_tabs() {
  swig_set_inner("redraw_tabs", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "redraw_tabs";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("redraw_tabs");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("redraw_tabs", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Tabs::tab_positions() {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("tab_positions", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "tab_positions";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("tab_positions");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("tab_positions", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Tabs::clear_tab_positions() {
  swig_set_inner("clear_tab_positions", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 16;
  const char *const swig_method_name = "clear_tab_positions";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("clear_tab_positions");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("clear_tab_positions", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Tabs::draw_tab(int x1,int x2,int W,int H,Fl_Widget *o,int flags,int sel) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x1));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(x2));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_NewPointerObj(SWIG_as_voidptr(o), SWIGTYPE_p_Fl_Widget,  0 );
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int((int)(flags));
  swig::SwigVar_PyObject obj6;
  obj6 = SWIG_From_int((int)(sel));
  swig_set_inner("draw_tab", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 17;
  const char *const swig_method_name = "draw_tab";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw_tab");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6, NULL);
#endif
  swig_set_inner("draw_tab", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Tabs::tab_height() {
  int c_result = SwigValueInit< int >() ;
  
  swig_set_inner("tab_height", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 18;
  const char *const swig_method_name = "tab_height";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("tab_height");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("tab_height", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Tabs::hit_close(Fl_Widget *o,int event_x,int event_y) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(o), SWIGTYPE_p_Fl_Widget,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(event_x));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(event_y));
  swig_set_inner("hit_close", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 19;
  const char *const swig_method_name = "hit_close";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hit_close");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL);
#endif
  swig_set_inner("hit_close", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Tabs::hit_overflow_menu(int event_x,int event_y) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event_x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(event_y));
  swig_set_inner("hit_overflow_menu", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 20;
  const char *const swig_method_name = "hit_overflow_menu";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hit_overflow_menu");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  swig_set_inner("hit_overflow_menu", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Tabs::hit_tabs_area(int event_x,int event_y) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event_x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(event_y));
  swig_set_inner("hit_tabs_area", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 21;
  const char *const swig_method_name = "hit_tabs_area";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hit_tabs_area");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  swig_set_inner("hit_tabs_area", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


Fl_Widget *SwigDirector_Fl_Tabs::which(int event_x,int event_y) {
  Fl_Widget *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event_x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(event_y));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tabs.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 22;
  const char *const swig_method_name = "which";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("which");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Widget,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Widget *""'");
  }
  c_result = (Fl_Widget *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Widget *) c_result;
}


SwigDirector_Fl_Terminal::SwigDirector_Fl_Terminal(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Terminal(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Terminal *)this, this); 
}




SwigDirector_Fl_Terminal::SwigDirector_Fl_Terminal(PyObject *self,int X,int Y,int W,int H,char const *L,int rows,int cols,int hist): Fl_Terminal(X, Y, W, H, L, rows, cols, hist), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Terminal *)this, this); 
}




SwigDirector_Fl_Terminal::~SwigDirector_Fl_Terminal() {
}

void SwigDirector_Fl_Terminal::draw() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Terminal.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Terminal::handle(int e) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(e));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Terminal.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Terminal::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Terminal.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Terminal::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Terminal.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Terminal::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Terminal.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Terminal::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Terminal.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Terminal::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Terminal.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Terminal::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Terminal.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Terminal::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Terminal.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Terminal::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Terminal.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Terminal::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Terminal.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Terminal::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Terminal.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Terminal::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Terminal.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Terminal::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Terminal::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Terminal::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Terminal::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Terminal.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Text_Display::SwigDirector_Fl_Text_Display(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Text_Display(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Text_Display *)this, this); 
}




SwigDirector_Fl_Text_Display::~SwigDirector_Fl_Text_Display() {
}

void SwigDirector_Fl_Text_Display::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Display.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Text_Display::handle(int e) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(e));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Display.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Text_Display::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Display.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Text_Display::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Display.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Text_Display::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Display.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Text_Display::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Display.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Text_Display::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Display.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Text_Display::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Display.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Text_Display::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Display.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Text_Display::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Display.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Text_Display::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Display.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Text_Display::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Display.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Text_Display::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Display.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Text_Display::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Text_Display::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Text_Display::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Text_Display::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Display.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Text_Display::recalc_display() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Display.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "recalc_display";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("recalc_display");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Text_Display::display_needs_recalc() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Display.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "display_needs_recalc";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("display_needs_recalc");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Text_Editor::SwigDirector_Fl_Text_Editor(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Text_Editor(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Text_Editor *)this, this); 
}




SwigDirector_Fl_Text_Editor::~SwigDirector_Fl_Text_Editor() {
}

void SwigDirector_Fl_Text_Editor::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Editor.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Text_Editor::handle(int e) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(e));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Editor.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Text_Editor::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Editor.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Text_Editor::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Editor.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Text_Editor::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Editor.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Text_Editor::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Editor.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Text_Editor::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Editor.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Text_Editor::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Editor.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Text_Editor::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Editor.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Text_Editor::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Editor.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Text_Editor::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Editor.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Text_Editor::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Editor.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Text_Editor::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Editor.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Text_Editor::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Text_Editor::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Text_Editor::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Text_Editor::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Editor.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Text_Editor::recalc_display() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Editor.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "recalc_display";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("recalc_display");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Text_Editor::display_needs_recalc() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Text_Editor.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "display_needs_recalc";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("display_needs_recalc");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Tile::SwigDirector_Fl_Tile(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Tile(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Tile *)this, this); 
}




SwigDirector_Fl_Tile::~SwigDirector_Fl_Tile() {
}

void SwigDirector_Fl_Tile::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tile.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Tile::handle(int event) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(event));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tile.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Tile::resize(int X,int Y,int W,int H) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tile.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Tile::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tile.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Tile::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tile.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Tile::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tile.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Tile::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tile.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Tile::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tile.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Tile::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tile.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Tile::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tile.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Tile::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tile.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Tile::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tile.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Tile::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tile.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Tile::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Tile::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Tile::on_move(int arg0,int arg1) {
  return Fl_Tile::on_move(arg0,arg1);
}


void SwigDirector_Fl_Tile::on_remove(int arg0) {
  Fl_Tile::on_remove(arg0);
}


int SwigDirector_Fl_Tile::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tile.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Tile::move_intersection(int oldx,int oldy,int newx,int newy) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(oldx));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(oldy));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(newx));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(newy));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tile.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "move_intersection";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("move_intersection");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Tile::drag_intersection(int oldx,int oldy,int newx,int newy) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(oldx));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(oldy));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(newx));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(newy));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tile.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char *const swig_method_name = "drag_intersection";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("drag_intersection");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Tiled_Image::SwigDirector_Fl_Tiled_Image(PyObject *self,Fl_Image *i,int W,int H): Fl_Tiled_Image(i, W, H), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Tiled_Image *)this, this); 
}




void SwigDirector_Fl_Tiled_Image::release() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tiled_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "release";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("release");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Shared_Image *SwigDirector_Fl_Tiled_Image::as_shared_image() {
  Fl_Shared_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tiled_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "as_shared_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_shared_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Shared_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Shared_Image *""'");
  }
  c_result = (Fl_Shared_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Shared_Image *) c_result;
}


SwigDirector_Fl_Tiled_Image::~SwigDirector_Fl_Tiled_Image() {
}

Fl_Image *SwigDirector_Fl_Tiled_Image::copy(int W,int H) const {
  Fl_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tiled_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "copy";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("copy");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Image *""'");
  }
  c_result = (Fl_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Image *) c_result;
}


void SwigDirector_Fl_Tiled_Image::color_average(Fl_Color c,float i) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_unsigned_SS_int((unsigned int)(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(i));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tiled_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "color_average";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("color_average");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Tiled_Image::desaturate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tiled_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "desaturate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("desaturate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Tiled_Image::label(Fl_Widget *w) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(w), SWIGTYPE_p_Fl_Widget,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tiled_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Tiled_Image::label(Fl_Menu_Item *m) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(m), SWIGTYPE_p_Fl_Menu_Item,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tiled_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Tiled_Image::draw(int X,int Y,int W,int H,int cx,int cy) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int((int)(cy));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tiled_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Tiled_Image::uncache() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tiled_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "uncache";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("uncache");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Tiled_Image::scale(int width,int height,int proportional,int can_expand) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(width));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(height));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(proportional));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(can_expand));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tiled_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Toggle_Button::SwigDirector_Fl_Toggle_Button(PyObject *self,int X,int Y,int W,int H,char const *l): Fl_Toggle_Button(X, Y, W, H, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Toggle_Button *)this, this); 
}




SwigDirector_Fl_Toggle_Button::~SwigDirector_Fl_Toggle_Button() {
}

void SwigDirector_Fl_Toggle_Button::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Toggle_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Toggle_Button::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Toggle_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Toggle_Button::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Toggle_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Toggle_Button::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Toggle_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Toggle_Button::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Toggle_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Toggle_Button::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Toggle_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Toggle_Button::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Toggle_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Toggle_Button::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Toggle_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Toggle_Button::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Toggle_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Toggle_Button::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Toggle_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Toggle_Button::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Toggle_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Toggle_Button::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Toggle_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Toggle_Button::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Toggle_Button.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


SwigDirector_Fl_Value_Output::SwigDirector_Fl_Value_Output(PyObject *self,int x,int y,int w,int h,char const *l): Fl_Value_Output(x, y, w, h, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Value_Output *)this, this); 
}




SwigDirector_Fl_Value_Output::~SwigDirector_Fl_Value_Output() {
}

void SwigDirector_Fl_Value_Output::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Value_Output::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Value_Output::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Value_Output::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Value_Output::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Value_Output::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Value_Output::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Value_Output::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Value_Output::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Value_Output::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Value_Output::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Value_Output::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Value_Output::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Value_Output::format(char *format_string) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)format_string);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Value_Output.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "format";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("format");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Wizard::SwigDirector_Fl_Wizard(PyObject *self,int arg0,int arg1,int arg2,int arg3,char const *arg4): Fl_Wizard(arg0, arg1, arg2, arg3, arg4), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Wizard *)this, this); 
}




SwigDirector_Fl_Wizard::~SwigDirector_Fl_Wizard() {
}

void SwigDirector_Fl_Wizard::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Wizard.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Wizard::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Wizard.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Wizard::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Wizard.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Wizard::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Wizard.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Wizard::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Wizard.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Wizard::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Wizard.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Wizard::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Wizard.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Wizard::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Wizard.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Wizard::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Wizard.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Wizard::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Wizard.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Wizard::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Wizard.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Wizard::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Wizard.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Wizard::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Wizard.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Wizard::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Wizard::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Wizard::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Wizard::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Wizard.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_XBM_Image::SwigDirector_Fl_XBM_Image(PyObject *self,char const *filename): Fl_XBM_Image(filename), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_XBM_Image *)this, this); 
}




void SwigDirector_Fl_XBM_Image::release() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XBM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "release";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("release");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Shared_Image *SwigDirector_Fl_XBM_Image::as_shared_image() {
  Fl_Shared_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XBM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "as_shared_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_shared_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Shared_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Shared_Image *""'");
  }
  c_result = (Fl_Shared_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Shared_Image *) c_result;
}


SwigDirector_Fl_XBM_Image::~SwigDirector_Fl_XBM_Image() {
}

Fl_Image *SwigDirector_Fl_XBM_Image::copy(int W,int H) const {
  Fl_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XBM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "copy";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("copy");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Image *""'");
  }
  c_result = (Fl_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Image *) c_result;
}


void SwigDirector_Fl_XBM_Image::color_average(Fl_Color c,float i) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_unsigned_SS_int((unsigned int)(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(i));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XBM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "color_average";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("color_average");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_XBM_Image::desaturate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XBM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "desaturate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("desaturate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_XBM_Image::label(Fl_Widget *w) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(w), SWIGTYPE_p_Fl_Widget,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XBM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_XBM_Image::label(Fl_Menu_Item *m) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(m), SWIGTYPE_p_Fl_Menu_Item,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XBM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_XBM_Image::draw(int X,int Y,int W,int H,int cx,int cy) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int((int)(cy));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XBM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_XBM_Image::uncache() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XBM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "uncache";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("uncache");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_XBM_Image::scale(int width,int height,int proportional,int can_expand) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(width));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(height));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(proportional));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(can_expand));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XBM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_XPM_Image::SwigDirector_Fl_XPM_Image(PyObject *self,char const *filename): Fl_XPM_Image(filename), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_XPM_Image *)this, this); 
}




void SwigDirector_Fl_XPM_Image::release() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XPM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "release";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("release");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Shared_Image *SwigDirector_Fl_XPM_Image::as_shared_image() {
  Fl_Shared_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XPM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "as_shared_image";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_shared_image");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Shared_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Shared_Image *""'");
  }
  c_result = (Fl_Shared_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Shared_Image *) c_result;
}


SwigDirector_Fl_XPM_Image::~SwigDirector_Fl_XPM_Image() {
}

Fl_Image *SwigDirector_Fl_XPM_Image::copy(int W,int H) const {
  Fl_Image *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(H));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XPM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "copy";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("copy");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Image,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Image *""'");
  }
  c_result = (Fl_Image *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Image *) c_result;
}


void SwigDirector_Fl_XPM_Image::color_average(Fl_Color c,float i) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_unsigned_SS_int((unsigned int)(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(i));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XPM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "color_average";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("color_average");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_XPM_Image::desaturate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XPM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "desaturate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("desaturate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_XPM_Image::label(Fl_Widget *w) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(w), SWIGTYPE_p_Fl_Widget,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XPM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_XPM_Image::label(Fl_Menu_Item *m) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(m), SWIGTYPE_p_Fl_Menu_Item,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XPM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "label";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("label");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_XPM_Image::draw(int X,int Y,int W,int H,int cx,int cy) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int((int)(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int((int)(cy));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XPM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_XPM_Image::uncache() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XPM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "uncache";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("uncache");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_XPM_Image::scale(int width,int height,int proportional,int can_expand) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(width));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(height));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(proportional));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(can_expand));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_XPM_Image.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Tree_Item::SwigDirector_Fl_Tree_Item(PyObject *self,Fl_Tree_Prefs const &prefs): Fl_Tree_Item(prefs), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Tree_Item *)this, this); 
}




SwigDirector_Fl_Tree_Item::SwigDirector_Fl_Tree_Item(PyObject *self,Fl_Tree *tree): Fl_Tree_Item(tree), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Tree_Item *)this, this); 
}




SwigDirector_Fl_Tree_Item::SwigDirector_Fl_Tree_Item(PyObject *self,Fl_Tree_Item const *o): Fl_Tree_Item(o), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Tree_Item *)this, this); 
}




void SwigDirector_Fl_Tree_Item::draw_vertical_connector(int x,int y1,int y2,Fl_Tree_Prefs const &prefs) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(y2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(&prefs), SWIGTYPE_p_Fl_Tree_Prefs,  0 );
  swig_set_inner("draw_vertical_connector", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tree_Item.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw_vertical_connector";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw_vertical_connector");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  swig_set_inner("draw_vertical_connector", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Tree_Item::draw_horizontal_connector(int x1,int x2,int y,Fl_Tree_Prefs const &prefs) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x1));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(x2));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(&prefs), SWIGTYPE_p_Fl_Tree_Prefs,  0 );
  swig_set_inner("draw_horizontal_connector", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tree_Item.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "draw_horizontal_connector";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw_horizontal_connector");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  swig_set_inner("draw_horizontal_connector", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Tree_Item::~SwigDirector_Fl_Tree_Item() {
}

int SwigDirector_Fl_Tree_Item::draw_item_content(int render) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(render));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tree_Item.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "draw_item_content";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw_item_content");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Tree::SwigDirector_Fl_Tree(PyObject *self,int X,int Y,int W,int H,char const *L): Fl_Tree(X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Tree *)this, this); 
}




SwigDirector_Fl_Tree::~SwigDirector_Fl_Tree() {
}

void SwigDirector_Fl_Tree::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tree.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Tree::handle(int e) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(e));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tree.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Tree::resize(int arg0,int arg1,int arg2,int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tree.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Tree::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tree.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Tree::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tree.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Tree::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tree.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_Fl_Tree::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tree.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_Fl_Tree::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tree.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_Fl_Tree::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tree.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Tree::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tree.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_Fl_Tree::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tree.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_Fl_Tree::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tree.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_Fl_Tree::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tree.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_Fl_Tree::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_Fl_Tree::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_Fl_Tree::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_Fl_Tree::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Tree.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Paged_Device::SwigDirector_Fl_Paged_Device(PyObject *self): Fl_Paged_Device(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Paged_Device *)this, this); 
}




void SwigDirector_Fl_Paged_Device::end_current() {
  swig_set_inner("end_current", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Paged_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "end_current";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("end_current");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("end_current", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Paged_Device::set_current() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Paged_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "set_current";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("set_current");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


bool SwigDirector_Fl_Paged_Device::is_current() {
  bool c_result = SwigValueInit< bool >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Paged_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "is_current";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("is_current");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = (bool)(swig_val);
  return (bool) c_result;
}


SwigDirector_Fl_Paged_Device::~SwigDirector_Fl_Paged_Device() {
}

void SwigDirector_Fl_Paged_Device::translate(int x,int y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Paged_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "translate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("translate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Paged_Device::untranslate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Paged_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "untranslate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("untranslate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Paged_Device::printable_rect(int *w,int *h) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(w), SWIGTYPE_p_int,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(h), SWIGTYPE_p_int,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Paged_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "printable_rect";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("printable_rect");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Paged_Device::origin(int x,int y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Paged_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "origin";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("origin");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Paged_Device::origin(int *x,int *y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(x), SWIGTYPE_p_int,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(y), SWIGTYPE_p_int,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Paged_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "origin";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("origin");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Paged_Device::begin_job(int pagecount,int *frompage,int *topage,char **perr_message) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(pagecount));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(frompage), SWIGTYPE_p_int,  0 );
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(topage), SWIGTYPE_p_int,  0 );
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(perr_message), SWIGTYPE_p_p_char,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Paged_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "begin_job";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("begin_job");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Paged_Device::begin_page() {
  int c_result = SwigValueInit< int >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Paged_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "begin_page";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("begin_page");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Paged_Device::margins(int *left,int *top,int *right,int *bottom) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(left), SWIGTYPE_p_int,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(top), SWIGTYPE_p_int,  0 );
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(right), SWIGTYPE_p_int,  0 );
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(bottom), SWIGTYPE_p_int,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Paged_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "margins";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("margins");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Paged_Device::scale(float scale_x,float scale_y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_float((float)(scale_x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(scale_y));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Paged_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Paged_Device::rotate(float angle) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_float((float)(angle));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Paged_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "rotate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("rotate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Paged_Device::end_page() {
  int c_result = SwigValueInit< int >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Paged_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "end_page";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("end_page");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Paged_Device::end_job() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Paged_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "end_job";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("end_job");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_PDF_File_Surface::SwigDirector_Fl_PDF_File_Surface(PyObject *self): Fl_PDF_File_Surface(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_PDF_File_Surface *)this, this); 
}




void SwigDirector_Fl_PDF_File_Surface::end_current() {
  swig_set_inner("end_current", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PDF_File_Surface.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "end_current";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("end_current");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("end_current", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PDF_File_Surface::set_current() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PDF_File_Surface.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "set_current";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("set_current");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


bool SwigDirector_Fl_PDF_File_Surface::is_current() {
  bool c_result = SwigValueInit< bool >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PDF_File_Surface.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "is_current";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("is_current");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = (bool)(swig_val);
  return (bool) c_result;
}


SwigDirector_Fl_PDF_File_Surface::~SwigDirector_Fl_PDF_File_Surface() {
}

void SwigDirector_Fl_PDF_File_Surface::translate(int x,int y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PDF_File_Surface.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "translate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("translate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PDF_File_Surface::untranslate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PDF_File_Surface.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "untranslate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("untranslate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_PDF_File_Surface::printable_rect(int *w,int *h) {
  int c_result = SwigValueInit< int >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PDF_File_Surface.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "printable_rect";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("printable_rect");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_PDF_File_Surface::origin(int x,int y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PDF_File_Surface.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "origin";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("origin");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PDF_File_Surface::origin(int *x,int *y) {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PDF_File_Surface.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "origin";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("origin");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_PDF_File_Surface::begin_job(int arg0,int *arg1,int *arg2,char **arg3) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(arg1), SWIGTYPE_p_int,  0 );
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(arg2), SWIGTYPE_p_int,  0 );
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(arg3), SWIGTYPE_p_p_char,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PDF_File_Surface.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "begin_job";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("begin_job");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_PDF_File_Surface::begin_page() {
  int c_result = SwigValueInit< int >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PDF_File_Surface.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "begin_page";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("begin_page");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_PDF_File_Surface::margins(int *left,int *top,int *right,int *bottom) {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PDF_File_Surface.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "margins";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("margins");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PDF_File_Surface::scale(float s_x,float s_y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_float((float)(s_x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(s_y));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PDF_File_Surface.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PDF_File_Surface::rotate(float angle) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_float((float)(angle));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PDF_File_Surface.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "rotate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("rotate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_PDF_File_Surface::end_page() {
  int c_result = SwigValueInit< int >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PDF_File_Surface.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "end_page";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("end_page");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_PDF_File_Surface::end_job() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PDF_File_Surface.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "end_job";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("end_job");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_PostScript_File_Device::SwigDirector_Fl_PostScript_File_Device(PyObject *self): Fl_PostScript_File_Device(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_PostScript_File_Device *)this, this); 
}




void SwigDirector_Fl_PostScript_File_Device::end_current() {
  swig_set_inner("end_current", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PostScript_File_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "end_current";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("end_current");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("end_current", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PostScript_File_Device::set_current() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PostScript_File_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "set_current";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("set_current");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


bool SwigDirector_Fl_PostScript_File_Device::is_current() {
  bool c_result = SwigValueInit< bool >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PostScript_File_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "is_current";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("is_current");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = (bool)(swig_val);
  return (bool) c_result;
}


SwigDirector_Fl_PostScript_File_Device::~SwigDirector_Fl_PostScript_File_Device() {
}

void SwigDirector_Fl_PostScript_File_Device::translate(int x,int y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PostScript_File_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "translate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("translate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PostScript_File_Device::untranslate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PostScript_File_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "untranslate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("untranslate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_PostScript_File_Device::printable_rect(int *w,int *h) {
  int c_result = SwigValueInit< int >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PostScript_File_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "printable_rect";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("printable_rect");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_PostScript_File_Device::origin(int x,int y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PostScript_File_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "origin";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("origin");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PostScript_File_Device::origin(int *x,int *y) {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PostScript_File_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "origin";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("origin");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_PostScript_File_Device::begin_job(int pagecount,int *from,int *to,char **perr_message) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(pagecount));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(from), SWIGTYPE_p_int,  0 );
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(to), SWIGTYPE_p_int,  0 );
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(perr_message), SWIGTYPE_p_p_char,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PostScript_File_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "begin_job";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("begin_job");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_PostScript_File_Device::begin_page() {
  int c_result = SwigValueInit< int >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PostScript_File_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "begin_page";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("begin_page");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_PostScript_File_Device::margins(int *left,int *top,int *right,int *bottom) {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PostScript_File_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "margins";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("margins");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PostScript_File_Device::scale(float scale_x,float scale_y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_float((float)(scale_x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(scale_y));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PostScript_File_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_PostScript_File_Device::rotate(float angle) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_float((float)(angle));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PostScript_File_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "rotate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("rotate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_PostScript_File_Device::end_page() {
  int c_result = SwigValueInit< int >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PostScript_File_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "end_page";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("end_page");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_PostScript_File_Device::end_job() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_PostScript_File_Device.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "end_job";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("end_job");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_Fl_Printer::SwigDirector_Fl_Printer(PyObject *self): Fl_Printer(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Printer *)this, this); 
}




void SwigDirector_Fl_Printer::end_current() {
  swig_set_inner("end_current", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Printer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "end_current";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("end_current");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("end_current", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Printer::set_current() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Printer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "set_current";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("set_current");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


bool SwigDirector_Fl_Printer::is_current() {
  bool c_result = SwigValueInit< bool >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Printer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "is_current";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("is_current");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = (bool)(swig_val);
  return (bool) c_result;
}


SwigDirector_Fl_Printer::~SwigDirector_Fl_Printer() {
}

void SwigDirector_Fl_Printer::translate(int x,int y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Printer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "translate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("translate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Printer::untranslate() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Printer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "untranslate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("untranslate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Printer::printable_rect(int *w,int *h) {
  int c_result = SwigValueInit< int >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Printer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "printable_rect";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("printable_rect");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Printer::origin(int x,int y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Printer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "origin";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("origin");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Printer::origin(int *x,int *y) {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Printer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "origin";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("origin");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Printer::begin_job(int pagecount,int *frompage,int *topage,char **perr_message) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(pagecount));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(frompage), SWIGTYPE_p_int,  0 );
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(topage), SWIGTYPE_p_int,  0 );
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(perr_message), SWIGTYPE_p_p_char,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Printer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "begin_job";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("begin_job");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Printer::begin_page() {
  int c_result = SwigValueInit< int >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Printer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "begin_page";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("begin_page");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Printer::margins(int *left,int *top,int *right,int *bottom) {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Printer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "margins";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("margins");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Printer::scale(float scale_x,float scale_y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_float((float)(scale_x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float((float)(scale_y));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Printer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "scale";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("scale");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_Fl_Printer::rotate(float angle) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_float((float)(angle));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Printer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "rotate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("rotate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_Fl_Printer::end_page() {
  int c_result = SwigValueInit< int >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Printer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "end_page";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("end_page");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Printer::end_job() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Printer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char *const swig_method_name = "end_job";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("end_job");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_ListSelect::SwigDirector_ListSelect(PyObject *self,int x,int y,int w,int h,char *topLabel,char *bottomLabel): ListSelect(x, y, w, h, topLabel, bottomLabel), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((ListSelect *)this, this); 
}




SwigDirector_ListSelect::~SwigDirector_ListSelect() {
}

void SwigDirector_ListSelect::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ListSelect.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "draw";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("draw");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


int SwigDirector_ListSelect::handle(int arg0) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ListSelect.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "handle";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("handle");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


void SwigDirector_ListSelect::resize(int x,int y,int w,int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int((int)(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int((int)(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int((int)(h));
  swig_set_inner("resize", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ListSelect.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "resize";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resize");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL);
#endif
  swig_set_inner("resize", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_ListSelect::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ListSelect.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "show";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("show");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_ListSelect::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ListSelect.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "hide";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("hide");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


Fl_Group *SwigDirector_ListSelect::as_group() {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ListSelect.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Group const *SwigDirector_ListSelect::as_group() const {
  Fl_Group *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ListSelect.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "as_group";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_group");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Group,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Group const *""'");
  }
  c_result = (Fl_Group *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group const *) c_result;
}


Fl_Window *SwigDirector_ListSelect::as_window() {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ListSelect.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Window const *SwigDirector_ListSelect::as_window() const {
  Fl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ListSelect.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "as_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Window const *""'");
  }
  c_result = (Fl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window const *) c_result;
}


Fl_Gl_Window *SwigDirector_ListSelect::as_gl_window() {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ListSelect.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window *) c_result;
}


Fl_Gl_Window const *SwigDirector_ListSelect::as_gl_window() const {
  Fl_Gl_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ListSelect.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char *const swig_method_name = "as_gl_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_gl_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Gl_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Gl_Window const *""'");
  }
  c_result = (Fl_Gl_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Gl_Window const *) c_result;
}


Fl_Vk_Window *SwigDirector_ListSelect::as_vk_window() {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ListSelect.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window *) c_result;
}


Fl_Vk_Window const *SwigDirector_ListSelect::as_vk_window() const {
  Fl_Vk_Window *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ListSelect.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char *const swig_method_name = "as_vk_window";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("as_vk_window");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_Fl_Vk_Window,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Fl_Vk_Window const *""'");
  }
  c_result = (Fl_Vk_Window *)(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Vk_Window const *) c_result;
}


int SwigDirector_ListSelect::on_insert(Fl_Widget *arg0,int arg1) {
  return Fl_Group::on_insert(arg0,arg1);
}


int SwigDirector_ListSelect::on_move(int arg0,int arg1) {
  return Fl_Group::on_move(arg0,arg1);
}


void SwigDirector_ListSelect::on_remove(int arg0) {
  Fl_Group::on_remove(arg0);
}


int SwigDirector_ListSelect::delete_child(int n) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int((int)(n));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ListSelect.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char *const swig_method_name = "delete_child";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("delete_child");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = (int)(swig_val);
  return (int) c_result;
}


#ifdef __cplusplus
extern "C" {
#endif

  
// Patch 1767434, interactive pyFltk
#if (defined(_WIN32) || defined(__WIN32__)) && !defined(__CYGWIN__)
#include <conio.h>
#else
static void _exit_wait_loop(int fd, void* data)
{
    int* stdin_ready = (int*)data;
    *stdin_ready = 1;
}
#endif

static int _run_loop_interactive(void)
{
  PyGILState_STATE gstate;
#if (defined(_WIN32) || defined(__WIN32__)) && !defined(__CYGWIN__)
  gstate = PyGILState_Ensure();
  while (! _kbhit()) Fl::wait(0.1);
  PyGILState_Release(gstate);
#else
  int result;
  int stdin_ready = 0;
  const int fd = fileno(stdin);
  Fl::add_fd(fd, _exit_wait_loop, &stdin_ready);
  gstate = PyGILState_Ensure();
  while (!stdin_ready)
  {
      result = Fl::wait();
      if (!result) break;
  }
  PyGILState_Release(gstate);
  Fl::remove_fd(fd);
#endif
  return 0;
}
// End of patch 1767434, interactive pyFltk

SWIGINTERN PyObject *_wrap_fl_define_FL_ROUND_UP_BOX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_define_FL_ROUND_UP_BOX", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Boxtype)fl_define_FL_ROUND_UP_BOX(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_SHADOW_BOX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_define_FL_SHADOW_BOX", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Boxtype)fl_define_FL_SHADOW_BOX(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_ROUNDED_BOX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_define_FL_ROUNDED_BOX", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Boxtype)fl_define_FL_ROUNDED_BOX(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_RFLAT_BOX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_define_FL_RFLAT_BOX", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Boxtype)fl_define_FL_RFLAT_BOX(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_RSHADOW_BOX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_define_FL_RSHADOW_BOX", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Boxtype)fl_define_FL_RSHADOW_BOX(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_DIAMOND_BOX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_define_FL_DIAMOND_BOX", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Boxtype)fl_define_FL_DIAMOND_BOX(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_OVAL_BOX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_define_FL_OVAL_BOX", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Boxtype)fl_define_FL_OVAL_BOX(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_PLASTIC_UP_BOX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_define_FL_PLASTIC_UP_BOX", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Boxtype)fl_define_FL_PLASTIC_UP_BOX(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_GTK_UP_BOX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_define_FL_GTK_UP_BOX", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Boxtype)fl_define_FL_GTK_UP_BOX(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_GLEAM_UP_BOX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_define_FL_GLEAM_UP_BOX", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Boxtype)fl_define_FL_GLEAM_UP_BOX(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_OXY_UP_BOX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_define_FL_OXY_UP_BOX", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Boxtype)fl_define_FL_OXY_UP_BOX(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_box(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Boxtype result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_box" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = (Fl_Boxtype)(val1);
  {
    try {
      result = (Fl_Boxtype)fl_box(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_down(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Boxtype result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_down" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = (Fl_Boxtype)(val1);
  {
    try {
      result = (Fl_Boxtype)fl_down(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_frame__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  Fl_Boxtype result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_frame" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = (Fl_Boxtype)(val1);
  {
    try {
      result = (Fl_Boxtype)fl_frame(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_SHADOW_LABEL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Labeltype result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_define_FL_SHADOW_LABEL", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Labeltype)fl_define_FL_SHADOW_LABEL(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_ENGRAVED_LABEL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Labeltype result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_define_FL_ENGRAVED_LABEL", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Labeltype)fl_define_FL_ENGRAVED_LABEL(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_EMBOSSED_LABEL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Labeltype result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_define_FL_EMBOSSED_LABEL", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Labeltype)fl_define_FL_EMBOSSED_LABEL(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_MULTI_LABEL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Labeltype result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_define_FL_MULTI_LABEL", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Labeltype)fl_define_FL_MULTI_LABEL(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_ICON_LABEL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Labeltype result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_define_FL_ICON_LABEL", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Labeltype)fl_define_FL_ICON_LABEL(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_IMAGE_LABEL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Labeltype result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_define_FL_IMAGE_LABEL", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Labeltype)fl_define_FL_IMAGE_LABEL(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_inactive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Color result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_inactive" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  {
    try {
      result = (Fl_Color)fl_inactive(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_contrast_function(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Contrast_Function *arg1 = (Fl_Contrast_Function *) 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_unsigned_int_unsigned_int_int_int__unsigned_int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "fl_contrast_function" "', argument " "1"" of type '" "Fl_Contrast_Function *""'"); 
    }
  }
  {
    try {
      fl_contrast_function(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_contrast_level__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 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 '" "fl_contrast_level" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      fl_contrast_level(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_contrast_level__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)fl_contrast_level(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_contrast_level(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_contrast_level", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_fl_contrast_level__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_fl_contrast_level__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_contrast_level'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_contrast_level(int)\n"
    "    fl_contrast_level()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_contrast_mode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 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 '" "fl_contrast_mode" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      fl_contrast_mode(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_contrast_mode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)fl_contrast_mode(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_contrast_mode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_contrast_mode", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_fl_contrast_mode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_fl_contrast_mode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_contrast_mode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_contrast_mode(int)\n"
    "    fl_contrast_mode()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_contrast(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  Fl_Color arg2 ;
  int arg3 = (int) 0 ;
  int arg4 = (int) 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Fl_Color result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_contrast", 2, 4, 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 '" "fl_contrast" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_contrast" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_contrast" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_contrast" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  {
    try {
      result = (Fl_Color)fl_contrast(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_lightness(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_lightness" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  {
    try {
      result = (double)fl_lightness(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_luminance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_luminance" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  {
    try {
      result = (double)fl_luminance(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_color_average(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  Fl_Color arg2 ;
  float arg3 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Fl_Color result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_color_average", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_color_average" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_color_average" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_color_average" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = (float)(val3);
  {
    try {
      result = (Fl_Color)fl_color_average(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_lighter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Color result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_lighter" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  {
    try {
      result = (Fl_Color)fl_lighter(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_darker(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Color result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_darker" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  {
    try {
      result = (Fl_Color)fl_darker(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rgb_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  uchar arg1 ;
  uchar arg2 ;
  uchar arg3 ;
  unsigned char val1 ;
  int ecode1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_rgb_color" "', argument " "1"" of type '" "uchar""'");
  } 
  arg1 = (uchar)(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_rgb_color" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_rgb_color" "', argument " "3"" of type '" "uchar""'");
  } 
  arg3 = (uchar)(val3);
  {
    try {
      result = (Fl_Color)fl_rgb_color(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rgb_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  uchar arg1 ;
  unsigned char val1 ;
  int ecode1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_rgb_color" "', argument " "1"" of type '" "uchar""'");
  } 
  arg1 = (uchar)(val1);
  {
    try {
      result = (Fl_Color)fl_rgb_color(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rgb_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_rgb_color", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_fl_rgb_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_fl_rgb_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_rgb_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_rgb_color(uchar,uchar,uchar)\n"
    "    fl_rgb_color(uchar)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_gray_ramp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Color result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_gray_ramp" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      result = (Fl_Color)fl_gray_ramp(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_color_cube(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Fl_Color result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_color_cube", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_color_cube" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_color_cube" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_color_cube" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (Fl_Color)fl_color_cube(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_command_modifier(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_command_modifier", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)fl_command_modifier(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_control_modifier(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_control_modifier", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)fl_control_modifier(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 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_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_w" "', argument " "1"" of type '" "Fl_Image const *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  {
    try {
      result = (int)((Fl_Image const *)arg1)->w(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 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_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_h" "', argument " "1"" of type '" "Fl_Image const *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  {
    try {
      result = (int)((Fl_Image const *)arg1)->h(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_data_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 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_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_data_w" "', argument " "1"" of type '" "Fl_Image const *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  {
    try {
      result = (int)((Fl_Image const *)arg1)->data_w(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_data_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 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_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_data_h" "', argument " "1"" of type '" "Fl_Image const *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  {
    try {
      result = (int)((Fl_Image const *)arg1)->data_h(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 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_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_d" "', argument " "1"" of type '" "Fl_Image const *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  {
    try {
      result = (int)((Fl_Image const *)arg1)->d(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_ld(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 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_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_ld" "', argument " "1"" of type '" "Fl_Image const *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  {
    try {
      result = (int)((Fl_Image const *)arg1)->ld(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 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_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_count" "', argument " "1"" of type '" "Fl_Image const *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  {
    try {
      result = (int)((Fl_Image const *)arg1)->count(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 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_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_data" "', argument " "1"" of type '" "Fl_Image const *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  {
    try {
      result = (char **)((Fl_Image const *)arg1)->data(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    int height = arg1->data_h();
    int width = arg1->data_w();  // Get the image width
    int depth = arg1->d();       // Get the image depth (e.g., 3 for RGB)
    int size  = width * height * depth;
    
    const char *const *img_data = result;  // Access the image data
    
    // Create a bytes object
    PyObject *pyBytes = PyBytes_FromStringAndSize(NULL, size);  
    
    if (img_data != NULL) {
      // Copy the data into the bytes object
      memcpy(PyBytes_AsString(pyBytes), img_data[0], size);
    }
    
    resultobj = pyBytes;  // Set the output result to the new bytes object
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_fail(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 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_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_fail" "', argument " "1"" of type '" "Fl_Image const *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  {
    try {
      result = (int)((Fl_Image const *)arg1)->fail(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_release(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_release" "', argument " "1"" of type '" "Fl_Image *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Image::release();
        } else {
          (arg1)->release();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_as_shared_image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Shared_Image *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_as_shared_image" "', argument " "1"" of type '" "Fl_Image *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Shared_Image *)(arg1)->Fl_Image::as_shared_image();
        } else {
          result = (Fl_Shared_Image *)(arg1)->as_shared_image();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Shared_Image, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Fl_Image *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Image", 4, 4, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Image" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Image" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Image" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Image *)new SwigDirector_Fl_Image(arg1,arg2,arg3,arg4); 
      } else {
        result = (Fl_Image *)new Fl_Image(arg2,arg3,arg4); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Image" "', argument " "1"" of type '" "Fl_Image *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_copy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_copy" "', argument " "1"" of type '" "Fl_Image const *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Image_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Image_copy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Image *)((Fl_Image const *)arg1)->Fl_Image::copy(arg2,arg3);
        } else {
          result = (Fl_Image *)((Fl_Image const *)arg1)->copy(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, SWIG_POINTER_OWN |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_copy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_copy" "', argument " "1"" of type '" "Fl_Image const *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Image const *)arg1)->copy(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_copy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Image_copy", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Image_copy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Image_copy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Image_copy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Image::copy(int,int) const\n"
    "    Fl_Image::copy() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Image_color_average(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  Fl_Color arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Image_color_average", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_color_average" "', argument " "1"" of type '" "Fl_Image *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Image_color_average" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Image_color_average" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = (float)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Image::color_average(arg2,arg3);
        } else {
          (arg1)->color_average(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_inactive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_inactive" "', argument " "1"" of type '" "Fl_Image *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  {
    try {
      (arg1)->inactive(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_desaturate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_desaturate" "', argument " "1"" of type '" "Fl_Image *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Image::desaturate();
        } else {
          (arg1)->desaturate();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_label__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_label" "', argument " "1"" of type '" "Fl_Image *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Image_label" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Image::label(arg2);
        } else {
          (arg1)->label(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_label__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  Fl_Menu_Item *arg2 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_label" "', argument " "1"" of type '" "Fl_Image *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Image_label" "', argument " "2"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg2 = (Fl_Menu_Item *)(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Image::label(arg2);
        } else {
          (arg1)->label(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_label(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Image_label", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Widget, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Image_label__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Image_label__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Image_label'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Image::label(Fl_Widget *)\n"
    "    Fl_Image::label(Fl_Menu_Item *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Image_draw__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 = (int) 0 ;
  int arg7 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_draw" "', argument " "1"" of type '" "Fl_Image *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Image_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Image_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Image_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Image_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Image_draw" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Image_draw" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Image::draw(arg2,arg3,arg4,arg5,arg6,arg7);
        } else {
          (arg1)->draw(arg2,arg3,arg4,arg5,arg6,arg7);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_draw__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 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_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_draw" "', argument " "1"" of type '" "Fl_Image *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Image_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Image_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->draw(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_draw(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Image_draw", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Image_draw__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 5) && (argc <= 7)) {
    PyObject *retobj = _wrap_Fl_Image_draw__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Image_draw'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Image::draw(int,int,int,int,int,int)\n"
    "    Fl_Image::draw(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Image_uncache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_uncache" "', argument " "1"" of type '" "Fl_Image *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Image::uncache();
        } else {
          (arg1)->uncache();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_define_FL_IMAGE_LABEL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Labeltype result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Image_define_FL_IMAGE_LABEL", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Labeltype)Fl_Image::define_FL_IMAGE_LABEL(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_RGB_scaling__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_RGB_Scaling arg1 ;
  int val1 ;
  int ecode1 = 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 '" "Fl_Image_RGB_scaling" "', argument " "1"" of type '" "Fl_RGB_Scaling""'");
  } 
  arg1 = (Fl_RGB_Scaling)(val1);
  {
    try {
      Fl_Image::RGB_scaling(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_RGB_scaling__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Fl_RGB_Scaling result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Fl_RGB_Scaling)Fl_Image::RGB_scaling(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_RGB_scaling(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Image_RGB_scaling", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_Fl_Image_RGB_scaling__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Image_RGB_scaling__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Image_RGB_scaling'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Image::RGB_scaling(Fl_RGB_Scaling)\n"
    "    Fl_Image::RGB_scaling()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Image_scale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 = (int) 1 ;
  int arg5 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Image_scale", 3, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_scale" "', argument " "1"" of type '" "Fl_Image *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Image_scale" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Image_scale" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Image_scale" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Image_scale" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = (int)(val5);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Image::scale(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->scale(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_scaling_algorithm__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_RGB_Scaling arg1 ;
  int val1 ;
  int ecode1 = 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 '" "Fl_Image_scaling_algorithm" "', argument " "1"" of type '" "Fl_RGB_Scaling""'");
  } 
  arg1 = (Fl_RGB_Scaling)(val1);
  {
    try {
      Fl_Image::scaling_algorithm(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_scaling_algorithm__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Fl_RGB_Scaling result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Fl_RGB_Scaling)Fl_Image::scaling_algorithm(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_scaling_algorithm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Image_scaling_algorithm", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_Fl_Image_scaling_algorithm__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Image_scaling_algorithm__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Image_scaling_algorithm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Image::scaling_algorithm(Fl_RGB_Scaling)\n"
    "    Fl_Image::scaling_algorithm()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Image" "', argument " "1"" of type '" "Fl_Image *""'"); 
  }
  arg1 = (Fl_Image *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_RGB_Image__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  uchar *arg2 = (uchar *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 = (int) 3 ;
  int arg6 = (int) 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Fl_RGB_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 6)) SWIG_fail;
  arg1 = swig_obj[0];
  {
    /* Check if the input support the buffer protocol */
    Py_buffer view;
    const void * buffer;
    int failure = PyObject_GetBuffer(swig_obj[1], &view, PyBUF_CONTIG_RO);
    if (!failure) {
      // work with array object
      buffer = view.buf;
      PyBuffer_Release(&view);
      arg2 = (uchar *) buffer;
    } else {
      // work with list object
      // clear the error from PyObject_GetBuffer
      PyErr_Clear();
      buffer=0;
      /* Check if is a list */
      if (PyList_Check(swig_obj[1])) {
        Py_ssize_t size = PyList_Size(swig_obj[1]);
        int i = 0;
        arg2 = (uchar *) malloc((size+1)*sizeof(char));
        for (i = 0; i < size; i++) {
          PyObject *o = 	PyList_GetItem(swig_obj[1],i);
          if (PyInt_Check(o))
          arg2[i] = (uchar)PyInt_AsLong(o);
          else {
            PyErr_SetString(PyExc_TypeError,"list must contain ints");
            free(arg2);
            return NULL;
          }
        }
        arg2[i] = 0;
      } else {
        PyErr_SetString(PyExc_TypeError,"not a list or does not support single-segment readable buffer interface");
        return NULL;
      }
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_RGB_Image" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_RGB_Image" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_RGB_Image" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = (int)(val5);
  }
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fl_RGB_Image" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_RGB_Image *)new SwigDirector_Fl_RGB_Image(arg1,(uchar const *)arg2,arg3,arg4,arg5,arg6); 
      } else {
        result = (Fl_RGB_Image *)new Fl_RGB_Image((uchar const *)arg2,arg3,arg4,arg5,arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_RGB_Image, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_RGB_Image__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  uchar *arg2 = (uchar *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  Fl_RGB_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  arg1 = swig_obj[0];
  {
    /* Check if the input support the buffer protocol */
    Py_buffer view;
    const void * buffer;
    int failure = PyObject_GetBuffer(swig_obj[1], &view, PyBUF_CONTIG_RO);
    if (!failure) {
      // work with array object
      buffer = view.buf;
      PyBuffer_Release(&view);
      arg2 = (uchar *) buffer;
    } else {
      // work with list object
      // clear the error from PyObject_GetBuffer
      PyErr_Clear();
      buffer=0;
      /* Check if is a list */
      if (PyList_Check(swig_obj[1])) {
        Py_ssize_t size = PyList_Size(swig_obj[1]);
        int i = 0;
        arg2 = (uchar *) malloc((size+1)*sizeof(char));
        for (i = 0; i < size; i++) {
          PyObject *o = 	PyList_GetItem(swig_obj[1],i);
          if (PyInt_Check(o))
          arg2[i] = (uchar)PyInt_AsLong(o);
          else {
            PyErr_SetString(PyExc_TypeError,"list must contain ints");
            free(arg2);
            return NULL;
          }
        }
        arg2[i] = 0;
      } else {
        PyErr_SetString(PyExc_TypeError,"not a list or does not support single-segment readable buffer interface");
        return NULL;
      }
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_RGB_Image" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_RGB_Image" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_RGB_Image" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fl_RGB_Image" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Fl_RGB_Image" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = (int)(val7);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_RGB_Image *)new SwigDirector_Fl_RGB_Image(arg1,(uchar const *)arg2,arg3,arg4,arg5,arg6,arg7); 
      } else {
        result = (Fl_RGB_Image *)new Fl_RGB_Image((uchar const *)arg2,arg3,arg4,arg5,arg6,arg7); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_RGB_Image, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_RGB_Image__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  Fl_Pixmap *arg2 = (Fl_Pixmap *) 0 ;
  Fl_Color arg3 = (Fl_Color) FL_BACKGROUND_COLOR ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Fl_RGB_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Pixmap, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_RGB_Image" "', argument " "2"" of type '" "Fl_Pixmap const *""'"); 
  }
  arg2 = (Fl_Pixmap *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_RGB_Image" "', argument " "3"" of type '" "Fl_Color""'");
    } 
    arg3 = (Fl_Color)(val3);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_RGB_Image *)new SwigDirector_Fl_RGB_Image(arg1,(Fl_Pixmap const *)arg2,arg3); 
      } else {
        result = (Fl_RGB_Image *)new Fl_RGB_Image((Fl_Pixmap const *)arg2,arg3); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_RGB_Image, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_RGB_Image(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_RGB_Image", 0, 7, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    PyObject *retobj = _wrap_new_Fl_RGB_Image__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 4) && (argc <= 6)) {
    PyObject *retobj = _wrap_new_Fl_RGB_Image__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_new_Fl_RGB_Image__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_RGB_Image'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_RGB_Image::Fl_RGB_Image(uchar const *,int,int,int,int)\n"
    "    Fl_RGB_Image::Fl_RGB_Image(uchar const *,int,int,int,int,int)\n"
    "    Fl_RGB_Image::Fl_RGB_Image(PyObject *,Fl_Pixmap const *,Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_RGB_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_RGB_Image, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_RGB_Image" "', argument " "1"" of type '" "Fl_RGB_Image *""'"); 
  }
  arg1 = (Fl_RGB_Image *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_copy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_RGB_Image_copy" "', argument " "1"" of type '" "Fl_RGB_Image const *""'"); 
  }
  arg1 = (Fl_RGB_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_RGB_Image_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_RGB_Image_copy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Image *)((Fl_RGB_Image const *)arg1)->Fl_RGB_Image::copy(arg2,arg3);
        } else {
          result = (Fl_Image *)((Fl_RGB_Image const *)arg1)->copy(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, SWIG_POINTER_OWN |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_copy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_RGB_Image_copy" "', argument " "1"" of type '" "Fl_RGB_Image const *""'"); 
  }
  arg1 = (Fl_RGB_Image *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_RGB_Image const *)arg1)->copy(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_copy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_RGB_Image_copy", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_RGB_Image_copy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_RGB_Image_copy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_RGB_Image_copy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_RGB_Image::copy(int,int) const\n"
    "    Fl_RGB_Image::copy() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_color_average(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  Fl_Color arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_RGB_Image_color_average", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_RGB_Image_color_average" "', argument " "1"" of type '" "Fl_RGB_Image *""'"); 
  }
  arg1 = (Fl_RGB_Image *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_RGB_Image_color_average" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_RGB_Image_color_average" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = (float)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_RGB_Image::color_average(arg2,arg3);
        } else {
          (arg1)->color_average(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_desaturate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_RGB_Image_desaturate" "', argument " "1"" of type '" "Fl_RGB_Image *""'"); 
  }
  arg1 = (Fl_RGB_Image *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_RGB_Image::desaturate();
        } else {
          (arg1)->desaturate();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_draw__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 = (int) 0 ;
  int arg7 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_RGB_Image_draw" "', argument " "1"" of type '" "Fl_RGB_Image *""'"); 
  }
  arg1 = (Fl_RGB_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_RGB_Image_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_RGB_Image_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_RGB_Image_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_RGB_Image_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_RGB_Image_draw" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_RGB_Image_draw" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_RGB_Image::draw(arg2,arg3,arg4,arg5,arg6,arg7);
        } else {
          (arg1)->draw(arg2,arg3,arg4,arg5,arg6,arg7);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_draw__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 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_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_RGB_Image_draw" "', argument " "1"" of type '" "Fl_RGB_Image *""'"); 
  }
  arg1 = (Fl_RGB_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_RGB_Image_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_RGB_Image_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->draw(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_draw(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_RGB_Image_draw", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_RGB_Image_draw__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 5) && (argc <= 7)) {
    PyObject *retobj = _wrap_Fl_RGB_Image_draw__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_RGB_Image_draw'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_RGB_Image::draw(int,int,int,int,int,int)\n"
    "    Fl_RGB_Image::draw(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_label__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_RGB_Image_label" "', argument " "1"" of type '" "Fl_RGB_Image *""'"); 
  }
  arg1 = (Fl_RGB_Image *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_RGB_Image_label" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_RGB_Image::label(arg2);
        } else {
          (arg1)->label(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_label__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  Fl_Menu_Item *arg2 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_RGB_Image_label" "', argument " "1"" of type '" "Fl_RGB_Image *""'"); 
  }
  arg1 = (Fl_RGB_Image *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_RGB_Image_label" "', argument " "2"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg2 = (Fl_Menu_Item *)(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_RGB_Image::label(arg2);
        } else {
          (arg1)->label(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_label(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_RGB_Image_label", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Widget, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_RGB_Image_label__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_RGB_Image_label__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_RGB_Image_label'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_RGB_Image::label(Fl_Widget *)\n"
    "    Fl_RGB_Image::label(Fl_Menu_Item *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_uncache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_RGB_Image_uncache" "', argument " "1"" of type '" "Fl_RGB_Image *""'"); 
  }
  arg1 = (Fl_RGB_Image *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_RGB_Image::uncache();
        } else {
          (arg1)->uncache();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_cache_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 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_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_RGB_Image_cache_w" "', argument " "1"" of type '" "Fl_RGB_Image *""'"); 
  }
  arg1 = (Fl_RGB_Image *)(argp1);
  {
    try {
      result = (int)(arg1)->cache_w(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_cache_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 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_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_RGB_Image_cache_h" "', argument " "1"" of type '" "Fl_RGB_Image *""'"); 
  }
  arg1 = (Fl_RGB_Image *)(argp1);
  {
    try {
      result = (int)(arg1)->cache_h(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_max_size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_RGB_Image_max_size" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = (size_t)(val1);
  {
    try {
      Fl_RGB_Image::max_size(SWIG_STD_MOVE(arg1)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_max_size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  size_t result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = Fl_RGB_Image::max_size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t((size_t)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_max_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_RGB_Image_max_size", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_Fl_RGB_Image_max_size__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_RGB_Image_max_size__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_RGB_Image_max_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_RGB_Image::max_size(size_t)\n"
    "    Fl_RGB_Image::max_size()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_as_svg_image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_SVG_Image *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_RGB_Image_as_svg_image" "', argument " "1"" of type '" "Fl_RGB_Image *""'"); 
  }
  arg1 = (Fl_RGB_Image *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_SVG_Image *)(arg1)->Fl_RGB_Image::as_svg_image();
        } else {
          result = (Fl_SVG_Image *)(arg1)->as_svg_image();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_SVG_Image, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_normalize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_RGB_Image_normalize" "', argument " "1"" of type '" "Fl_RGB_Image *""'"); 
  }
  arg1 = (Fl_RGB_Image *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_RGB_Image::normalize();
        } else {
          (arg1)->normalize();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_RGB_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_RGB_Image" "', argument " "1"" of type '" "Fl_RGB_Image *""'"); 
  }
  arg1 = (Fl_RGB_Image *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Label_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Label *arg1 = (Fl_Label *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  Fl_Align arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Label_draw", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Label, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Label_draw" "', argument " "1"" of type '" "Fl_Label const *""'"); 
  }
  arg1 = (Fl_Label *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Label_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Label_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Label_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Label_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Label_draw" "', argument " "6"" of type '" "Fl_Align""'");
  } 
  arg6 = (Fl_Align)(val6);
  {
    try {
      ((Fl_Label const *)arg1)->draw(arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Label_measure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Label *arg1 = (Fl_Label *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int res2 = 0 ;
  int temp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Label_measure", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Label, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Label_measure" "', argument " "1"" of type '" "Fl_Label const *""'"); 
  }
  arg1 = (Fl_Label *)(argp1);
  if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
    int val;
    int ecode = SWIG_AsVal_int(swig_obj[1], &val);
    if (!SWIG_IsOK(ecode)) {
      SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Fl_Label_measure" "', argument " "2"" of type '" "int""'");
    }
    temp2 = (int)(val);
    arg2 = &temp2;
    res2 = SWIG_AddTmpMask(ecode);
  }
  if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
    int val;
    int ecode = SWIG_AsVal_int(swig_obj[2], &val);
    if (!SWIG_IsOK(ecode)) {
      SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Fl_Label_measure" "', argument " "3"" of type '" "int""'");
    }
    temp3 = (int)(val);
    arg3 = &temp3;
    res3 = SWIG_AddTmpMask(ecode);
  }
  {
    try {
      ((Fl_Label const *)arg1)->measure(*arg2,*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Label(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Label *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Label", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Label *)new Fl_Label(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Label, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Label(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Label *arg1 = (Fl_Label *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Label, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Label" "', argument " "1"" of type '" "Fl_Label *""'"); 
  }
  arg1 = (Fl_Label *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Callback_User_Data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  Fl_Callback_User_Data *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Callback_User_Data *)new SwigDirector_Fl_Callback_User_Data(arg1); 
      } else {
        SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
        SWIG_fail;
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Callback_User_Data, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Callback_User_Data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Callback_User_Data *arg1 = (Fl_Callback_User_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Callback_User_Data, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Callback_User_Data" "', argument " "1"" of type '" "Fl_Callback_User_Data *""'"); 
  }
  arg1 = (Fl_Callback_User_Data *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Callback_User_Data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Callback_User_Data *arg1 = (Fl_Callback_User_Data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Callback_User_Data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Callback_User_Data" "', argument " "1"" of type '" "Fl_Callback_User_Data *""'"); 
  }
  arg1 = (Fl_Callback_User_Data *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Widget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0L ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Widget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Widget", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Widget" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Widget" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Widget" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Widget" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Widget" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Widget *)new SwigDirector_Fl_Widget(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
        SWIG_fail;
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Widget, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Widget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Widget" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_draw" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Fl_Widget::draw");
        } else {
          (arg1)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Widget_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_handle" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Widget::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_is_label_copied(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_is_label_copied" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (int)((Fl_Widget const *)arg1)->is_label_copied(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_needs_keyboard__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_needs_keyboard" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_needs_keyboard" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = (bool)(val2);
  {
    try {
      (arg1)->needs_keyboard(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_needs_keyboard__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_needs_keyboard" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (bool)((Fl_Widget const *)arg1)->needs_keyboard(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_needs_keyboard(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_needs_keyboard", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_needs_keyboard__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_needs_keyboard__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_needs_keyboard'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::needs_keyboard(bool)\n"
    "    Fl_Widget::needs_keyboard() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_parent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Group *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_parent" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (Fl_Group *)((Fl_Widget const *)arg1)->parent(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Group, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_parent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Group *arg2 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_parent" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_parent" "', argument " "2"" of type '" "Fl_Group *""'"); 
  }
  arg2 = (Fl_Group *)(argp2);
  {
    try {
      (arg1)->parent(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_parent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_parent", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_parent__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_parent__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_parent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::parent() const\n"
    "    Fl_Widget::parent(Fl_Group *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_type__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_type" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (uchar)((Fl_Widget const *)arg1)->type(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_type__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_type" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_type" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  {
    try {
      (arg1)->type(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_type(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_type", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_type__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_type__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_type'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::type() const\n"
    "    Fl_Widget::type(uchar)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_x(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_x" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (int)((Fl_Widget const *)arg1)->x(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_y(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_y" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (int)((Fl_Widget const *)arg1)->y(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_w" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (int)((Fl_Widget const *)arg1)->w(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_h" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (int)((Fl_Widget const *)arg1)->h(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Widget_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_resize" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Widget_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Widget_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Widget::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_damage_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Widget_damage_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_damage_resize" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_damage_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_damage_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Widget_damage_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Widget_damage_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      result = (int)(arg1)->damage_resize(arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_position(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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, "Fl_Widget_position", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_position" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_position" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_position" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->position(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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, "Fl_Widget_size", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_size" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_size" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->size(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_align__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Align result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_align" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (Fl_Align)((Fl_Widget const *)arg1)->align(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_align__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Align arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_align" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_align" "', argument " "2"" of type '" "Fl_Align""'");
  } 
  arg2 = (Fl_Align)(val2);
  {
    try {
      (arg1)->align(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_align(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_align", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_align__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_align__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_align'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::align() const\n"
    "    Fl_Widget::align(Fl_Align)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_box__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Boxtype result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_box" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (Fl_Boxtype)((Fl_Widget const *)arg1)->box(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_box__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Boxtype 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_box" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_box" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = (Fl_Boxtype)(val2);
  {
    try {
      (arg1)->box(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_box(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_box", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_box__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_box__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_box'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::box() const\n"
    "    Fl_Widget::box(Fl_Boxtype)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_color" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Widget const *)arg1)->color(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_color" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->color(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_selection_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_selection_color" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Widget const *)arg1)->selection_color(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_selection_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_selection_color" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_selection_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->selection_color(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_selection_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_selection_color", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_selection_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_selection_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_selection_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::selection_color() const\n"
    "    Fl_Widget::selection_color(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_color__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Color arg2 ;
  Fl_Color arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_color" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_color" "', argument " "3"" of type '" "Fl_Color""'");
  } 
  arg3 = (Fl_Color)(val3);
  {
    try {
      (arg1)->color(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_color", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Widget_color__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::color() const\n"
    "    Fl_Widget::color(Fl_Color)\n"
    "    Fl_Widget::color(Fl_Color,Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_label__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_label" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (char *)((Fl_Widget const *)arg1)->label(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_label__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_label" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_label" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->label((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_copy_label(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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, "Fl_Widget_copy_label", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_copy_label" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_copy_label" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->copy_label((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_label__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Labeltype arg2 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_label" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_label" "', argument " "2"" of type '" "Fl_Labeltype""'");
  } 
  arg2 = (Fl_Labeltype)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Widget_label" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      (arg1)->label(arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_label(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_label", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_label__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_label__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Widget_label__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_label'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::label() const\n"
    "    Fl_Widget::label(char const *)\n"
    "    Fl_Widget::label(Fl_Labeltype,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labeltype__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Labeltype result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_labeltype" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (Fl_Labeltype)((Fl_Widget const *)arg1)->labeltype(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labeltype__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Labeltype 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_labeltype" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_labeltype" "', argument " "2"" of type '" "Fl_Labeltype""'");
  } 
  arg2 = (Fl_Labeltype)(val2);
  {
    try {
      (arg1)->labeltype(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labeltype(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_labeltype", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_labeltype__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_labeltype__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_labeltype'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::labeltype() const\n"
    "    Fl_Widget::labeltype(Fl_Labeltype)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labelcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_labelcolor" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Widget const *)arg1)->labelcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labelcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_labelcolor" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_labelcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->labelcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labelcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_labelcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_labelcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_labelcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_labelcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::labelcolor() const\n"
    "    Fl_Widget::labelcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labelfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_labelfont" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Widget const *)arg1)->labelfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labelfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Font 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_labelfont" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_labelfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->labelfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labelfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_labelfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_labelfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_labelfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_labelfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::labelfont() const\n"
    "    Fl_Widget::labelfont(Fl_Font)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labelsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_labelsize" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Widget const *)arg1)->labelsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labelsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Fontsize 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_labelsize" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_labelsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->labelsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labelsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_labelsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_labelsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_labelsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_labelsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::labelsize() const\n"
    "    Fl_Widget::labelsize(Fl_Fontsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_image__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_image" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (Fl_Image *)(arg1)->image(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_image__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_image" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Widget const *)arg1)->image(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_image__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Image *arg2 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_image" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_image" "', argument " "2"" of type '" "Fl_Image *""'"); 
  }
  arg2 = (Fl_Image *)(argp2);
  {
    try {
      (arg1)->image(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_image(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_image", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_image__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_image__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_image__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_image'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::image()\n"
    "    Fl_Widget::image() const\n"
    "    Fl_Widget::image(Fl_Image *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_bind_image__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Image *arg2 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_bind_image" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_bind_image" "', argument " "2"" of type '" "Fl_Image *""'"); 
  }
  arg2 = (Fl_Image *)(argp2);
  {
    try {
      (arg1)->bind_image(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_bind_image__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_bind_image" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_bind_image" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->bind_image(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_bind_image(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_bind_image", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Image, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Widget_bind_image__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_bind_image__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_bind_image'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::bind_image(Fl_Image *)\n"
    "    Fl_Widget::bind_image(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_image_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_image_bound" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (int)((Fl_Widget const *)arg1)->image_bound(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_deimage__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_deimage" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (Fl_Image *)(arg1)->deimage(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_deimage__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_deimage" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Widget const *)arg1)->deimage(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_deimage__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Image *arg2 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_deimage" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_deimage" "', argument " "2"" of type '" "Fl_Image *""'"); 
  }
  arg2 = (Fl_Image *)(argp2);
  {
    try {
      (arg1)->deimage(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_deimage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_deimage", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_deimage__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_deimage__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_deimage__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_deimage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::deimage()\n"
    "    Fl_Widget::deimage() const\n"
    "    Fl_Widget::deimage(Fl_Image *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_bind_deimage__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Image *arg2 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_bind_deimage" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_bind_deimage" "', argument " "2"" of type '" "Fl_Image *""'"); 
  }
  arg2 = (Fl_Image *)(argp2);
  {
    try {
      (arg1)->bind_deimage(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_deimage_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_deimage_bound" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (int)((Fl_Widget const *)arg1)->deimage_bound(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_bind_deimage__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_bind_deimage" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_bind_deimage" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->bind_deimage(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_bind_deimage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_bind_deimage", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Image, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Widget_bind_deimage__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_bind_deimage__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_bind_deimage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::bind_deimage(Fl_Image *)\n"
    "    Fl_Widget::bind_deimage(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_label_image_spacing__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_label_image_spacing" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_label_image_spacing" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->label_image_spacing(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_label_image_spacing__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_label_image_spacing" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (int)(arg1)->label_image_spacing(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_label_image_spacing(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_label_image_spacing", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_label_image_spacing__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_label_image_spacing__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_label_image_spacing'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::label_image_spacing(int)\n"
    "    Fl_Widget::label_image_spacing()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_horizontal_label_margin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_horizontal_label_margin" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_horizontal_label_margin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->horizontal_label_margin(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_horizontal_label_margin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_horizontal_label_margin" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (int)(arg1)->horizontal_label_margin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_horizontal_label_margin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_horizontal_label_margin", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_horizontal_label_margin__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_horizontal_label_margin__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_horizontal_label_margin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::horizontal_label_margin(int)\n"
    "    Fl_Widget::horizontal_label_margin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_vertical_label_margin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_vertical_label_margin" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_vertical_label_margin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->vertical_label_margin(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_vertical_label_margin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_vertical_label_margin" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (int)(arg1)->vertical_label_margin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_vertical_label_margin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_vertical_label_margin", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_vertical_label_margin__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_vertical_label_margin__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_vertical_label_margin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::vertical_label_margin(int)\n"
    "    Fl_Widget::vertical_label_margin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_tooltip__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_tooltip" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (char *)((Fl_Widget const *)arg1)->tooltip(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_tooltip__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_tooltip" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_tooltip" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->tooltip((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_tooltip(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_tooltip", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_tooltip__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_tooltip__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_tooltip'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::tooltip() const\n"
    "    Fl_Widget::tooltip(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_copy_tooltip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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, "Fl_Widget_copy_tooltip", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_copy_tooltip" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_copy_tooltip" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->copy_tooltip((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_callback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Callback_p result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_callback" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (Fl_Callback_p)((Fl_Widget const *)arg1)->callback(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_callback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Callback *arg2 = (Fl_Callback *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_callback" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Widget_callback" "', argument " "2"" of type '" "Fl_Callback *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Widget_callback" "', argument " "3"" of type '" "void *""'"); 
  }
  {
    try {
      (arg1)->callback(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_callback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Callback *arg2 = (Fl_Callback *) 0 ;
  Fl_Callback_User_Data *arg3 = (Fl_Callback_User_Data *) 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_callback" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Widget_callback" "', argument " "2"" of type '" "Fl_Callback *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Fl_Callback_User_Data, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Widget_callback" "', argument " "3"" of type '" "Fl_Callback_User_Data *""'"); 
  }
  arg3 = (Fl_Callback_User_Data *)(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Widget_callback" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = (bool)(val4);
  {
    try {
      (arg1)->callback(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_callback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Callback *arg2 = (Fl_Callback *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_callback" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Widget_callback" "', argument " "2"" of type '" "Fl_Callback *""'"); 
    }
  }
  {
    try {
      (arg1)->callback(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_callback__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Callback0 *arg2 = (Fl_Callback0 *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_callback" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_Fl_Widget__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Widget_callback" "', argument " "2"" of type '" "Fl_Callback0 *""'"); 
    }
  }
  {
    try {
      (arg1)->callback(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_callback__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Callback1 *arg2 = (Fl_Callback1 *) 0 ;
  long arg3 = (long) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_callback" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_Fl_Widget_long__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Widget_callback" "', argument " "2"" of type '" "Fl_Callback1 *""'"); 
    }
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_callback" "', argument " "3"" of type '" "long""'");
    } 
    arg3 = (long)(val3);
  }
  {
    try {
      (arg1)->callback(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_user_data__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Callback_User_Data *arg2 = (Fl_Callback_User_Data *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_user_data" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Callback_User_Data, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_user_data" "', argument " "2"" of type '" "Fl_Callback_User_Data *""'"); 
  }
  arg2 = (Fl_Callback_User_Data *)(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_user_data" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = (bool)(val3);
  {
    try {
      (arg1)->user_data(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_argument__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_argument" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (long)((Fl_Widget const *)arg1)->argument(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long((long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_argument__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_argument" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_argument" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = (long)(val2);
  {
    try {
      (arg1)->argument(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_argument(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_argument", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_argument__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_argument__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_argument'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::argument() const\n"
    "    Fl_Widget::argument(long)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_when__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_When result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_when" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (Fl_When)((Fl_Widget const *)arg1)->when(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_when__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_when" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_when" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  {
    try {
      (arg1)->when(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_when(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_when", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_when__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_when__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_when'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::when() const\n"
    "    Fl_Widget::when(uchar)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_visible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_visible" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (unsigned int)((Fl_Widget const *)arg1)->visible(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_visible_r(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_visible_r" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (int)((Fl_Widget const *)arg1)->visible_r(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_show(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_show" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Widget::show();
        } else {
          (arg1)->show();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_hide(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_hide" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Widget::hide();
        } else {
          (arg1)->hide();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_set_visible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_set_visible" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      (arg1)->set_visible(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_clear_visible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_clear_visible" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      (arg1)->clear_visible(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_active(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_active" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (unsigned int)((Fl_Widget const *)arg1)->active(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_active_r(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_active_r" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (int)((Fl_Widget const *)arg1)->active_r(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_activate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_activate" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      (arg1)->activate(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_deactivate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_deactivate" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      (arg1)->deactivate(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_output" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (unsigned int)((Fl_Widget const *)arg1)->output(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_set_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_set_output" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      (arg1)->set_output(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_clear_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_clear_output" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      (arg1)->clear_output(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_takesevents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_takesevents" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (unsigned int)((Fl_Widget const *)arg1)->takesevents(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_changed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_changed" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (unsigned int)((Fl_Widget const *)arg1)->changed(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_set_changed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_set_changed" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      (arg1)->set_changed(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_clear_changed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_clear_changed" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      (arg1)->clear_changed(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_clear_active(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_clear_active" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      (arg1)->clear_active(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_set_active(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_set_active" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      (arg1)->set_active(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_take_focus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_take_focus" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (int)(arg1)->take_focus(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_set_visible_focus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_set_visible_focus" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      (arg1)->set_visible_focus(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_clear_visible_focus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_clear_visible_focus" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      (arg1)->clear_visible_focus(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_visible_focus__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_visible_focus" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_visible_focus" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->visible_focus(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_visible_focus__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_visible_focus" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (unsigned int)((Fl_Widget const *)arg1)->visible_focus(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_visible_focus(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_visible_focus", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_visible_focus__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_visible_focus__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_visible_focus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::visible_focus(int)\n"
    "    Fl_Widget::visible_focus() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_default_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Widget_default_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_default_callback" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(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 '" "Fl_Widget_default_callback" "', argument " "2"" of type '" "void *""'"); 
  }
  {
    try {
      Fl_Widget::default_callback(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_do_callback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Callback_Reason arg2 = (Fl_Callback_Reason) FL_REASON_UNKNOWN ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_do_callback" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_do_callback" "', argument " "2"" of type '" "Fl_Callback_Reason""'");
    } 
    arg2 = (Fl_Callback_Reason)(val2);
  }
  {
    try {
      (arg1)->do_callback(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_do_callback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  long arg3 ;
  Fl_Callback_Reason arg4 = (Fl_Callback_Reason) FL_REASON_UNKNOWN ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_do_callback" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_do_callback" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_do_callback" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = (long)(val3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Widget_do_callback" "', argument " "4"" of type '" "Fl_Callback_Reason""'");
    } 
    arg4 = (Fl_Callback_Reason)(val4);
  }
  {
    try {
      (arg1)->do_callback(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_do_callback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *arg3 = (void *) 0 ;
  Fl_Callback_Reason arg4 = (Fl_Callback_Reason) FL_REASON_UNKNOWN ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_do_callback" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_do_callback" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  if (swig_obj[2]) {
    res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Widget_do_callback" "', argument " "3"" of type '" "void *""'"); 
    }
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Widget_do_callback" "', argument " "4"" of type '" "Fl_Callback_Reason""'");
    } 
    arg4 = (Fl_Callback_Reason)(val4);
  }
  {
    try {
      (arg1)->do_callback(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_do_callback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_do_callback", 0, 4, argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v = 0;
    if (argc > 1) {
      {
        {
          int res = SWIG_AsVal_int(argv[1], NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (!_v) goto check_1;
    }
    return _wrap_Fl_Widget_do_callback__SWIG_0(self, argc, argv);
  }
check_1:
  
  if ((argc >= 2) && (argc <= 4)) {
    int _v = 0;
    if (argc > 2) {
      {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
      }
      if (!_v) goto check_2;
    }
    PyObject *retobj = _wrap_Fl_Widget_do_callback__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_2:
  
  if ((argc >= 3) && (argc <= 4)) {
    PyObject *retobj = _wrap_Fl_Widget_do_callback__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_do_callback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::do_callback(Fl_Callback_Reason)\n"
    "    Fl_Widget::do_callback(Fl_Widget *,long,Fl_Callback_Reason)\n"
    "    Fl_Widget::do_callback(Fl_Widget *,void *,Fl_Callback_Reason)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_test_shortcut__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_test_shortcut" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (int)(arg1)->test_shortcut(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_label_shortcut(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_label_shortcut" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (unsigned int)Fl_Widget::label_shortcut((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_test_shortcut__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  bool arg2 = (bool) (bool)false ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 1) || (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 '" "Fl_Widget_test_shortcut" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_test_shortcut" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = (bool)(val2);
  }
  {
    try {
      result = (int)Fl_Widget::test_shortcut((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_test_shortcut(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_test_shortcut", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Fl_Widget, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Widget_test_shortcut__SWIG_0(self, argc, argv);
  }
check_1:
  
  if ((argc >= 1) && (argc <= 2)) {
    PyObject *retobj = _wrap_Fl_Widget_test_shortcut__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_test_shortcut'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::test_shortcut()\n"
    "    Fl_Widget::test_shortcut(char const *,bool const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget__set_fullscreen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget__set_fullscreen" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      (arg1)->_set_fullscreen(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget__clear_fullscreen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget__clear_fullscreen" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      (arg1)->_clear_fullscreen(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_contains(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 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, "Fl_Widget_contains", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_contains" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_contains" "', argument " "2"" of type '" "Fl_Widget const *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  {
    try {
      result = (int)((Fl_Widget const *)arg1)->contains((Fl_Widget const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_inside(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 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, "Fl_Widget_inside", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_inside" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_inside" "', argument " "2"" of type '" "Fl_Widget const *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  {
    try {
      result = (int)((Fl_Widget const *)arg1)->inside((Fl_Widget const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_redraw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_redraw" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      (arg1)->redraw(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_redraw_label(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_redraw_label" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      (arg1)->redraw_label(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_damage__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_damage" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (uchar)((Fl_Widget const *)arg1)->damage(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_clear_damage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  uchar arg2 = (uchar) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Widget_clear_damage", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_clear_damage" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_clear_damage" "', argument " "2"" of type '" "uchar""'");
    } 
    arg2 = (uchar)(val2);
  }
  {
    try {
      (arg1)->clear_damage(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_damage__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_damage" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_damage" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  {
    try {
      (arg1)->damage(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_damage__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  uchar arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_damage" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_damage" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_damage" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Widget_damage" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Widget_damage" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Widget_damage" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  {
    try {
      (arg1)->damage(arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_damage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_damage", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_damage__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_damage__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_Fl_Widget_damage__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_damage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::damage() const\n"
    "    Fl_Widget::damage(uchar)\n"
    "    Fl_Widget::damage(uchar,int,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_draw_label__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  Fl_Align arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_draw_label" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_draw_label" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_draw_label" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Widget_draw_label" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Widget_draw_label" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Widget_draw_label" "', argument " "6"" of type '" "Fl_Align""'");
  } 
  arg6 = (Fl_Align)(val6);
  {
    try {
      ((Fl_Widget const *)arg1)->draw_label(arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_measure_label(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int res2 = 0 ;
  int temp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Widget_measure_label", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_measure_label" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
    int val;
    int ecode = SWIG_AsVal_int(swig_obj[1], &val);
    if (!SWIG_IsOK(ecode)) {
      SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Fl_Widget_measure_label" "', argument " "2"" of type '" "int""'");
    }
    temp2 = (int)(val);
    arg2 = &temp2;
    res2 = SWIG_AddTmpMask(ecode);
  }
  if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
    int val;
    int ecode = SWIG_AsVal_int(swig_obj[2], &val);
    if (!SWIG_IsOK(ecode)) {
      SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Fl_Widget_measure_label" "', argument " "3"" of type '" "int""'");
    }
    temp3 = (int)(val);
    arg3 = &temp3;
    res3 = SWIG_AddTmpMask(ecode);
  }
  {
    try {
      ((Fl_Widget const *)arg1)->measure_label(*arg2,*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Window *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_window" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (Fl_Window *)((Fl_Widget const *)arg1)->window(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_top_window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Window *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_top_window" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (Fl_Window *)((Fl_Widget const *)arg1)->top_window(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_top_window_offset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  Fl_Window *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Widget_top_window_offset", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_top_window_offset" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_top_window_offset" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Widget_top_window_offset" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = (int *)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Widget_top_window_offset" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Widget_top_window_offset" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = (int *)(argp3);
  {
    try {
      result = (Fl_Window *)((Fl_Widget const *)arg1)->top_window_offset(*arg2,*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_as_group__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Group *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_as_group" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Group *)(arg1)->Fl_Widget::as_group();
        } else {
          result = (Fl_Group *)(arg1)->as_group();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_as_group__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Group *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_as_group" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Group *)((Fl_Widget const *)arg1)->Fl_Widget::as_group();
        } else {
          result = (Fl_Group *)((Fl_Widget const *)arg1)->as_group();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_as_group(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_as_group", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_as_group__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_as_group__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_as_group'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::as_group()\n"
    "    Fl_Widget::as_group() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_as_window__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_as_window" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Window *)(arg1)->Fl_Widget::as_window();
        } else {
          result = (Fl_Window *)(arg1)->as_window();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_as_window__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_as_window" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Window *)((Fl_Widget const *)arg1)->Fl_Widget::as_window();
        } else {
          result = (Fl_Window *)((Fl_Widget const *)arg1)->as_window();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_as_window(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_as_window", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_as_window__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_as_window__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_as_window'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::as_window()\n"
    "    Fl_Widget::as_window() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_as_gl_window__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Gl_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_as_gl_window" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Gl_Window *)(arg1)->Fl_Widget::as_gl_window();
        } else {
          result = (Fl_Gl_Window *)(arg1)->as_gl_window();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_as_gl_window__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Gl_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_as_gl_window" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Gl_Window *)((Fl_Widget const *)arg1)->Fl_Widget::as_gl_window();
        } else {
          result = (Fl_Gl_Window *)((Fl_Widget const *)arg1)->as_gl_window();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_as_gl_window(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_as_gl_window", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_as_gl_window__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_as_gl_window__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_as_gl_window'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::as_gl_window()\n"
    "    Fl_Widget::as_gl_window() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_as_vk_window__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Vk_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_as_vk_window" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Vk_Window *)(arg1)->Fl_Widget::as_vk_window();
        } else {
          result = (Fl_Vk_Window *)(arg1)->as_vk_window();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Vk_Window, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_as_vk_window__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Vk_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_as_vk_window" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Vk_Window *)((Fl_Widget const *)arg1)->Fl_Widget::as_vk_window();
        } else {
          result = (Fl_Vk_Window *)((Fl_Widget const *)arg1)->as_vk_window();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Vk_Window, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_as_vk_window(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_as_vk_window", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_as_vk_window__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_as_vk_window__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_as_vk_window'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::as_vk_window()\n"
    "    Fl_Widget::as_vk_window() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_use_accents_menu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_use_accents_menu" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (int)(arg1)->use_accents_menu(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_shortcut_label__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_shortcut_label" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_shortcut_label" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->shortcut_label(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_shortcut_label__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_shortcut_label" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (int)((Fl_Widget const *)arg1)->shortcut_label(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_shortcut_label(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_shortcut_label", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_shortcut_label__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_shortcut_label__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_shortcut_label'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::shortcut_label(int)\n"
    "    Fl_Widget::shortcut_label() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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, "Fl_Widget_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_init_type" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Widget_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_draw_label__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_draw_label" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      Fl_Widget_draw_label__SWIG_1(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_draw_label(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_draw_label", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_draw_label__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_Fl_Widget_draw_label__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_draw_label'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::draw_label(int,int,int,int,Fl_Align) const\n"
    "    Fl_Widget::draw_label()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_draw_backdrop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_draw_backdrop" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      Fl_Widget_draw_backdrop(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_callback__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  PyObject *arg4 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_callback" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  if (swig_obj[3]) {
    arg4 = swig_obj[3];
  }
  {
    try {
      Fl_Widget_callback__SWIG_6(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_callback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_callback", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_callback__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_Fl_Widget_callback__SWIG_3(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    int _v = 0;
    {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_Fl_Widget__void);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_Fl_Widget_callback__SWIG_4(self, argc, argv);
  }
check_3:
  
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_Fl_Widget_long__void);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    if (argc > 2) {
      {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (!_v) goto check_4;
    }
    return _wrap_Fl_Widget_callback__SWIG_5(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    return _wrap_Fl_Widget_callback__SWIG_1(self, argc, argv);
  }
check_5:
  
  if ((argc >= 3) && (argc <= 4)) {
    int _v = 0;
    {
      _v = (argv[1] != 0);
    }
    if (!_v) goto check_6;
    {
      _v = (argv[2] != 0);
    }
    if (!_v) goto check_6;
    if (argc > 3) {
      {
        _v = (argv[3] != 0);
      }
      if (!_v) goto check_6;
    }
    return _wrap_Fl_Widget_callback__SWIG_6(self, argc, argv);
  }
check_6:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_Fl_Widget_callback__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_callback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::callback() const\n"
    "    Fl_Widget::callback(Fl_Callback *,void *)\n"
    "    Fl_Widget::callback(Fl_Callback *,Fl_Callback_User_Data *,bool)\n"
    "    Fl_Widget::callback(Fl_Callback *)\n"
    "    Fl_Widget::callback(Fl_Callback0 *)\n"
    "    Fl_Widget::callback(Fl_Callback1 *,long)\n"
    "    Fl_Widget::callback(PyObject *,PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_user_data__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  PyObject *arg2 = (PyObject *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_user_data" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  arg2 = swig_obj[1];
  {
    try {
      Fl_Widget_user_data__SWIG_1(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_user_data__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_user_data" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (PyObject *)Fl_Widget_user_data__SWIG_2(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_user_data(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_user_data", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Widget_user_data__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Widget_user_data__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Widget_user_data__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_user_data'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::user_data(Fl_Callback_User_Data *,bool)\n"
    "    Fl_Widget::user_data(PyObject *)\n"
    "    Fl_Widget::user_data()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Widget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Widget" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Widget_Surface_translate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget_Surface *arg1 = (Fl_Widget_Surface *) 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, "Fl_Widget_Surface_translate", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_Surface_translate" "', argument " "1"" of type '" "Fl_Widget_Surface *""'"); 
  }
  arg1 = (Fl_Widget_Surface *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_Surface_translate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_Surface_translate" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->translate(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_Surface_untranslate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget_Surface *arg1 = (Fl_Widget_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_Surface_untranslate" "', argument " "1"" of type '" "Fl_Widget_Surface *""'"); 
  }
  arg1 = (Fl_Widget_Surface *)(argp1);
  {
    try {
      (arg1)->untranslate(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_Surface_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget_Surface *arg1 = (Fl_Widget_Surface *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  int arg3 = (int) 0 ;
  int arg4 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Widget_Surface_draw", 2, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_Surface_draw" "', argument " "1"" of type '" "Fl_Widget_Surface *""'"); 
  }
  arg1 = (Fl_Widget_Surface *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_Surface_draw" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_Surface_draw" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Widget_Surface_draw" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  {
    try {
      (arg1)->draw(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_Surface_draw_decorated_window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget_Surface *arg1 = (Fl_Widget_Surface *) 0 ;
  Fl_Window *arg2 = (Fl_Window *) 0 ;
  int arg3 = (int) 0 ;
  int arg4 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Widget_Surface_draw_decorated_window", 2, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_Surface_draw_decorated_window" "', argument " "1"" of type '" "Fl_Widget_Surface *""'"); 
  }
  arg1 = (Fl_Widget_Surface *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_Surface_draw_decorated_window" "', argument " "2"" of type '" "Fl_Window *""'"); 
  }
  arg2 = (Fl_Window *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_Surface_draw_decorated_window" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Widget_Surface_draw_decorated_window" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  {
    try {
      (arg1)->draw_decorated_window(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_Surface_print_window_part(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget_Surface *arg1 = (Fl_Widget_Surface *) 0 ;
  Fl_Window *arg2 = (Fl_Window *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 = (int) 0 ;
  int arg8 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject *swig_obj[8] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Widget_Surface_print_window_part", 6, 8, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_Surface_print_window_part" "', argument " "1"" of type '" "Fl_Widget_Surface *""'"); 
  }
  arg1 = (Fl_Widget_Surface *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_Surface_print_window_part" "', argument " "2"" of type '" "Fl_Window *""'"); 
  }
  arg2 = (Fl_Window *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_Surface_print_window_part" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Widget_Surface_print_window_part" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Widget_Surface_print_window_part" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Widget_Surface_print_window_part" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Widget_Surface_print_window_part" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  if (swig_obj[7]) {
    ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Fl_Widget_Surface_print_window_part" "', argument " "8"" of type '" "int""'");
    } 
    arg8 = (int)(val8);
  }
  {
    try {
      (arg1)->print_window_part(arg2,arg3,arg4,arg5,arg6,arg7,arg8); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_Surface_printable_rect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget_Surface *arg1 = (Fl_Widget_Surface *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Widget_Surface_printable_rect", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_Surface_printable_rect" "', argument " "1"" of type '" "Fl_Widget_Surface *""'"); 
  }
  arg1 = (Fl_Widget_Surface *)(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 '" "Fl_Widget_Surface_printable_rect" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (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 '" "Fl_Widget_Surface_printable_rect" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  {
    try {
      result = (int)(arg1)->printable_rect(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_Surface_origin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget_Surface *arg1 = (Fl_Widget_Surface *) 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_Fl_Widget_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_Surface_origin" "', argument " "1"" of type '" "Fl_Widget_Surface *""'"); 
  }
  arg1 = (Fl_Widget_Surface *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_Surface_origin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_Surface_origin" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->origin(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_Surface_origin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget_Surface *arg1 = (Fl_Widget_Surface *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 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_Fl_Widget_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_Surface_origin" "', argument " "1"" of type '" "Fl_Widget_Surface *""'"); 
  }
  arg1 = (Fl_Widget_Surface *)(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 '" "Fl_Widget_Surface_origin" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (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 '" "Fl_Widget_Surface_origin" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  {
    try {
      (arg1)->origin(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_Surface_origin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Widget_Surface_origin", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Widget_Surface_origin__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Widget_Surface_origin__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Widget_Surface_origin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget_Surface::origin(int,int)\n"
    "    Fl_Widget_Surface::origin(int *,int *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Widget_Surface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget_Surface *arg1 = (Fl_Widget_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget_Surface, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Widget_Surface" "', argument " "1"" of type '" "Fl_Widget_Surface *""'"); 
  }
  arg1 = (Fl_Widget_Surface *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_Fl_Group_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Group *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_draw" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Group *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Group_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_handle" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Group_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Group::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_begin" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  {
    try {
      (arg1)->begin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_end" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  {
    try {
      (arg1)->end(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_current__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Swig::Director *director = 0;
  Fl_Group *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Fl_Group *)Fl_Group::current(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Group, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_current__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 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_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_current" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  {
    try {
      Fl_Group::current(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_current(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Group_current", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_Fl_Group_current__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Group_current__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Group_current'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Group::current()\n"
    "    Fl_Group::current(Fl_Group *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Group_children(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 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_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_children" "', argument " "1"" of type '" "Fl_Group const *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  {
    try {
      result = (int)((Fl_Group const *)arg1)->children(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_child(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Group_child", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_child" "', argument " "1"" of type '" "Fl_Group const *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Group_child" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (Fl_Widget *)((Fl_Group const *)arg1)->child(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    {
      const std::string lookup_typename = std::string("_p_") + std::string(reinterpret_cast<CallbackStruct*>(result->user_data())->type_name);
      //printf("Type = %s\n", lookup_typename.c_str());
      swig_type_info * const outtype = SWIG_TypeQuery(lookup_typename.c_str());
      //if (outtype == 0)
      //  printf("SWIG Type not found\n");
      //else
      //  printf("Swig Type = %s\n", outtype->str);
      resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), outtype, 0);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  Fl_Widget *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, "Fl_Group_find", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_find" "', argument " "1"" of type '" "Fl_Group const *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Widget,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Group_find" "', argument " "2"" of type '" "Fl_Widget const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Group_find" "', argument " "2"" of type '" "Fl_Widget const &""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  {
    try {
      result = (int)((Fl_Group const *)arg1)->find((Fl_Widget const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Group_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_resize" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Group_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Group_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Group_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Group_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Group::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Group(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Group *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Group", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Group" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Group" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Group" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Group" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Group" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Group *)new SwigDirector_Fl_Group(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Group *)new Fl_Group(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Group, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Group(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Group" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_add(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Group_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_add" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Group_add" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  {
    try {
      (arg1)->add(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  Fl_Widget *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Group_insert", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_insert" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Widget,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Group_insert" "', argument " "2"" of type '" "Fl_Widget &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Group_insert" "', argument " "2"" of type '" "Fl_Widget &""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Group_insert" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->insert(*arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_insert_before(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  Fl_Widget *arg2 = 0 ;
  Fl_Widget *arg3 = (Fl_Widget *) 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, "Fl_Group_insert_before", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_insert_before" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Widget,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Group_insert_before" "', argument " "2"" of type '" "Fl_Widget &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Group_insert_before" "', argument " "2"" of type '" "Fl_Widget &""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Group_insert_before" "', argument " "3"" of type '" "Fl_Widget *""'"); 
  }
  arg3 = (Fl_Widget *)(argp3);
  {
    try {
      (arg1)->insert(*arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_remove__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 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_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_remove" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Group_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->remove(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_remove__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_remove" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Group_remove" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  {
    try {
      (arg1)->remove(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Group_remove", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Widget, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Group_remove__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Group_remove__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Group_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Group::remove(int)\n"
    "    Fl_Group::remove(Fl_Widget *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Group_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_clear" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_delete_child(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Group_delete_child", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_delete_child" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Group_delete_child" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Group::delete_child(arg2);
        } else {
          result = (int)(arg1)->delete_child(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_resizable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_resizable" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Group_resizable" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  {
    try {
      (arg1)->resizable(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_resizable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_resizable" "', argument " "1"" of type '" "Fl_Group const *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  {
    try {
      result = (Fl_Widget *)((Fl_Group const *)arg1)->resizable(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Widget, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_resizable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Group_resizable", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Group_resizable__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Group_resizable__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Group_resizable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Group::resizable(Fl_Widget *)\n"
    "    Fl_Group::resizable() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Group_add_resizable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  Fl_Widget *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Group_add_resizable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_add_resizable" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Widget,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Group_add_resizable" "', argument " "2"" of type '" "Fl_Widget &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Group_add_resizable" "', argument " "2"" of type '" "Fl_Widget &""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  {
    try {
      (arg1)->add_resizable(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_init_sizes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_init_sizes" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  {
    try {
      (arg1)->init_sizes(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_clip_children__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 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_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_clip_children" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Group_clip_children" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->clip_children(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_clip_children__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_clip_children" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  {
    try {
      result = (unsigned int)(arg1)->clip_children(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_clip_children(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Group_clip_children", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Group_clip_children__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Group_clip_children__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Group_clip_children'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Group::clip_children(int)\n"
    "    Fl_Group::clip_children()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Group_as_group__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Group *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_as_group" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Group *)(arg1)->Fl_Group::as_group();
        } else {
          result = (Fl_Group *)(arg1)->as_group();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Group, 0 |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_as_group__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Group *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_as_group" "', argument " "1"" of type '" "Fl_Group const *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Group *)((Fl_Group const *)arg1)->Fl_Group::as_group();
        } else {
          result = (Fl_Group *)((Fl_Group const *)arg1)->as_group();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Group, 0 |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_as_group(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Group_as_group", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Group_as_group__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Group_as_group__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Group_as_group'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Group::as_group()\n"
    "    Fl_Group::as_group() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Group__ddfdesign_kludge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Widget **result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group__ddfdesign_kludge" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  {
    try {
      result = (Fl_Widget **) &(arg1)->_ddfdesign_kludge(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_Fl_Widget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 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, "Fl_Group_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_init_type" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Group_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Group_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Group(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Group" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = (Fl_Group *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_End(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_End *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_End", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_End *)new Fl_End(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_End, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_End(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_End *arg1 = (Fl_End *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_End, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_End" "', argument " "1"" of type '" "Fl_End *""'"); 
  }
  arg1 = (Fl_End *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Browser__item_first(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__item_first" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_first"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_first");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Fl_Browser_::item_first");
        } else {
          result = (void *)((SwigDirector_Fl_Browser_ const *)darg)->item_first();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__item_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser__item_next", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__item_next" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(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 '" "Fl_Browser__item_next" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_next"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_next");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Fl_Browser_::item_next");
        } else {
          result = (void *)((SwigDirector_Fl_Browser_ const *)darg)->item_next(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__item_prev(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser__item_prev", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__item_prev" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(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 '" "Fl_Browser__item_prev" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_prev"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_prev");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Fl_Browser_::item_prev");
        } else {
          result = (void *)((SwigDirector_Fl_Browser_ const *)darg)->item_prev(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__item_last(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__item_last" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_last"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_last");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Browser_ const *)darg)->item_lastSwigPublic();
        } else {
          result = (void *)((SwigDirector_Fl_Browser_ const *)darg)->item_last();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__item_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser__item_height", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__item_height" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(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 '" "Fl_Browser__item_height" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Fl_Browser_::item_height");
        } else {
          result = (int)((SwigDirector_Fl_Browser_ const *)darg)->item_height(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__item_width(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser__item_width", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__item_width" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(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 '" "Fl_Browser__item_width" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_width"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_width");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Fl_Browser_::item_width");
        } else {
          result = (int)((SwigDirector_Fl_Browser_ const *)darg)->item_width(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__item_quick_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser__item_quick_height", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__item_quick_height" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(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 '" "Fl_Browser__item_quick_height" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_quick_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_quick_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Browser_ const *)darg)->item_quick_heightSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Browser_ const *)darg)->item_quick_height(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__item_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser__item_draw", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__item_draw" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(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 '" "Fl_Browser__item_draw" "', 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 '" "Fl_Browser__item_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Browser__item_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Browser__item_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Browser__item_draw" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Fl_Browser_::item_draw");
        } else {
          ((SwigDirector_Fl_Browser_ const *)darg)->item_draw(arg2,arg3,arg4,arg5,arg6);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__item_text(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser__item_text", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__item_text" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(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 '" "Fl_Browser__item_text" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_text"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_text");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    {
      try {
        if (upcall) {
          result = (char *)((SwigDirector_Fl_Browser_ const *)darg)->item_textSwigPublic(arg2);
        } else {
          result = (char *)((SwigDirector_Fl_Browser_ const *)darg)->item_text(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (director) {
    director->swig_release_ownership(SWIG_as_voidptr(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__item_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *arg2 = (void *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser__item_swap", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__item_swap" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(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 '" "Fl_Browser__item_swap" "', argument " "2"" of type '" "void *""'"); 
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Browser__item_swap" "', argument " "3"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_swap"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_swap");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->item_swapSwigPublic(arg2,arg3);
        } else {
          (darg)->item_swap(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__item_at(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser__item_at", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__item_at" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__item_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_at"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_at");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Browser_ const *)darg)->item_atSwigPublic(arg2);
        } else {
          result = (void *)((SwigDirector_Fl_Browser_ const *)darg)->item_at(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__full_width(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__full_width" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("full_width"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member full_width");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Browser_ const *)darg)->full_widthSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Browser_ const *)darg)->full_width();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__full_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__full_height" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("full_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member full_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Browser_ const *)darg)->full_heightSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Browser_ const *)darg)->full_height();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__incr_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__incr_height" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("incr_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member incr_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Browser_ const *)darg)->incr_heightSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Browser_ const *)darg)->incr_height();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__item_select(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser__item_select", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__item_select" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(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 '" "Fl_Browser__item_select" "', argument " "2"" of type '" "void *""'"); 
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser__item_select" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_select"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_select");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->item_selectSwigPublic(arg2,arg3);
        } else {
          (darg)->item_select(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__item_selected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser__item_selected", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__item_selected" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(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 '" "Fl_Browser__item_selected" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_selected"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_selected");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Browser_ const *)darg)->item_selectedSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Browser_ const *)darg)->item_selected(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__draw" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Browser_(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Browser_ *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Browser_", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Browser_" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Browser_" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Browser_" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Browser_" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Browser_" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Browser_ *)new SwigDirector_Fl_Browser_(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
        SWIG_fail;
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Browser_, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser__handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__handle" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Browser_::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser__resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__resize" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser__resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Browser__resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Browser__resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Browser_::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__select(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 = (int) 1 ;
  int arg4 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser__select", 2, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__select" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(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 '" "Fl_Browser__select" "', argument " "2"" of type '" "void *""'"); 
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser__select" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Browser__select" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  {
    try {
      result = (int)(arg1)->select(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__select_only(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser__select_only", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__select_only" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(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 '" "Fl_Browser__select_only" "', argument " "2"" of type '" "void *""'"); 
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser__select_only" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->select_only(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__deselect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  int arg2 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser__deselect", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__deselect" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__deselect" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      result = (int)(arg1)->deselect(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__vposition__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 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_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__vposition" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  {
    try {
      result = (int)((Fl_Browser_ const *)arg1)->vposition(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__vposition__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 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_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__vposition" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__vposition" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->vposition(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__vposition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser__vposition", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Browser__vposition__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Browser__vposition__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser__vposition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser_::vposition() const\n"
    "    Fl_Browser_::vposition(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__hposition__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 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_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__hposition" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  {
    try {
      result = (int)((Fl_Browser_ const *)arg1)->hposition(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__hposition__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 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_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__hposition" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__hposition" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->hposition(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__hposition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser__hposition", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Browser__hposition__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Browser__hposition__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser__hposition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser_::hposition() const\n"
    "    Fl_Browser_::hposition(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__display(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser__display", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__display" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(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 '" "Fl_Browser__display" "', argument " "2"" of type '" "void *""'"); 
  }
  {
    try {
      (arg1)->display(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__has_scrollbar__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__has_scrollbar" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  {
    try {
      result = (uchar)((Fl_Browser_ const *)arg1)->has_scrollbar(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__has_scrollbar__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__has_scrollbar" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__has_scrollbar" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  {
    try {
      (arg1)->has_scrollbar(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__has_scrollbar(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser__has_scrollbar", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Browser__has_scrollbar__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Browser__has_scrollbar__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser__has_scrollbar'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser_::has_scrollbar() const\n"
    "    Fl_Browser_::has_scrollbar(uchar)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__textfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__textfont" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Browser_ const *)arg1)->textfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__textfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  Fl_Font 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_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__textfont" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->textfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__textfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser__textfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Browser__textfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Browser__textfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser__textfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser_::textfont() const\n"
    "    Fl_Browser_::textfont(Fl_Font)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__textsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__textsize" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Browser_ const *)arg1)->textsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__textsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  Fl_Fontsize 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_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__textsize" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->textsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__textsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser__textsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Browser__textsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Browser__textsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser__textsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser_::textsize() const\n"
    "    Fl_Browser_::textsize(Fl_Fontsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__textcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__textcolor" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Browser_ const *)arg1)->textcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__textcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__textcolor" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->textcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__textcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser__textcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Browser__textcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Browser__textcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser__textcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser_::textcolor() const\n"
    "    Fl_Browser_::textcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__scrollbar_size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 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_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__scrollbar_size" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  {
    try {
      result = (int)((Fl_Browser_ const *)arg1)->scrollbar_size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__scrollbar_size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 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_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__scrollbar_size" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__scrollbar_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->scrollbar_size(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__scrollbar_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser__scrollbar_size", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Browser__scrollbar_size__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Browser__scrollbar_size__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser__scrollbar_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser_::scrollbar_size() const\n"
    "    Fl_Browser_::scrollbar_size(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__scrollbar_width__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 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_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__scrollbar_width" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  {
    try {
      result = (int)((Fl_Browser_ const *)arg1)->scrollbar_width(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__scrollbar_width__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 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_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__scrollbar_width" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__scrollbar_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->scrollbar_width(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__scrollbar_width(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser__scrollbar_width", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Browser__scrollbar_width__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Browser__scrollbar_width__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser__scrollbar_width'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser_::scrollbar_width() const\n"
    "    Fl_Browser_::scrollbar_width(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__scrollbar_right(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__scrollbar_right" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  {
    try {
      (arg1)->scrollbar_right(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__scrollbar_left(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__scrollbar_left" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  {
    try {
      (arg1)->scrollbar_left(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__sort(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  int arg2 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser__sort", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__sort" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__sort" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      (arg1)->sort(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__linespacing__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 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_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__linespacing" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__linespacing" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->linespacing(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__linespacing__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 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_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__linespacing" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  {
    try {
      result = (int)((Fl_Browser_ const *)arg1)->linespacing(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__linespacing(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser__linespacing", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Browser__linespacing__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Browser__linespacing__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser__linespacing'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser_::linespacing(int)\n"
    "    Fl_Browser_::linespacing() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 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, "Fl_Browser__init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__init_type" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Browser__init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Browser__init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__getScrollbar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Scrollbar *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__getScrollbar" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  {
    try {
      result = (Fl_Scrollbar *)Fl_Browser__getScrollbar(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Scrollbar, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__getHScrollbar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Scrollbar *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__getHScrollbar" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  {
    try {
      result = (Fl_Scrollbar *)Fl_Browser__getHScrollbar(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Scrollbar, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Browser_(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Browser_" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Browser_(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Browser_" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = (Fl_Browser_ *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Browser_item_first(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_item_first" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_first"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_first");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Browser const *)darg)->item_firstSwigPublic();
        } else {
          result = (void *)((SwigDirector_Fl_Browser const *)darg)->item_first();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_item_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser_item_next", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_item_next" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(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 '" "Fl_Browser_item_next" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_next"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_next");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Browser const *)darg)->item_nextSwigPublic(arg2);
        } else {
          result = (void *)((SwigDirector_Fl_Browser const *)darg)->item_next(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_item_prev(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser_item_prev", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_item_prev" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(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 '" "Fl_Browser_item_prev" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_prev"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_prev");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Browser const *)darg)->item_prevSwigPublic(arg2);
        } else {
          result = (void *)((SwigDirector_Fl_Browser const *)darg)->item_prev(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_item_last(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_item_last" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_last"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_last");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Browser const *)darg)->item_lastSwigPublic();
        } else {
          result = (void *)((SwigDirector_Fl_Browser const *)darg)->item_last();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_item_selected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser_item_selected", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_item_selected" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(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 '" "Fl_Browser_item_selected" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_selected"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_selected");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Browser const *)darg)->item_selectedSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Browser const *)darg)->item_selected(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_item_select(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser_item_select", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_item_select" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(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 '" "Fl_Browser_item_select" "', 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 '" "Fl_Browser_item_select" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_select"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_select");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->item_selectSwigPublic(arg2,arg3);
        } else {
          (darg)->item_select(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_item_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser_item_height", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_item_height" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(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 '" "Fl_Browser_item_height" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Browser const *)darg)->item_heightSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Browser const *)darg)->item_height(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_item_width(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser_item_width", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_item_width" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(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 '" "Fl_Browser_item_width" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_width"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_width");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Browser const *)darg)->item_widthSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Browser const *)darg)->item_width(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_item_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser_item_draw", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_item_draw" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(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 '" "Fl_Browser_item_draw" "', 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 '" "Fl_Browser_item_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Browser_item_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Browser_item_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Browser_item_draw" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    {
      try {
        if (upcall) {
          ((SwigDirector_Fl_Browser const *)darg)->item_drawSwigPublic(arg2,arg3,arg4,arg5,arg6);
        } else {
          ((SwigDirector_Fl_Browser const *)darg)->item_draw(arg2,arg3,arg4,arg5,arg6);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_full_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_full_height" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("full_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member full_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Browser const *)darg)->full_heightSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Browser const *)darg)->full_height();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_incr_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_incr_height" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("incr_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member incr_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Browser const *)darg)->incr_heightSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Browser const *)darg)->incr_height();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_item_text(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser_item_text", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_item_text" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(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 '" "Fl_Browser_item_text" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_text"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_text");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (char *)((SwigDirector_Fl_Browser const *)darg)->item_textSwigPublic(arg2);
        } else {
          result = (char *)((SwigDirector_Fl_Browser const *)darg)->item_text(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (director) {
    director->swig_release_ownership(SWIG_as_voidptr(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_item_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser_item_swap", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_item_swap" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(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 '" "Fl_Browser_item_swap" "', argument " "2"" of type '" "void *""'"); 
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Browser_item_swap" "', argument " "3"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_swap"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_swap");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->item_swapSwigPublic(arg2,arg3);
        } else {
          (darg)->item_swap(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_item_at(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser_item_at", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_item_at" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_item_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_at"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_at");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Browser const *)darg)->item_atSwigPublic(arg2);
        } else {
          result = (void *)((SwigDirector_Fl_Browser const *)darg)->item_at(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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, "Fl_Browser_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_remove" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->remove(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_move(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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, "Fl_Browser_move", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_move" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_move" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser_move" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->move(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_load(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  char *arg2 = (char *) 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, "Fl_Browser_load", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_load" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Browser_load" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)(arg1)->load((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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, "Fl_Browser_swap", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_swap" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_swap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser_swap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->swap(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_clear" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_size" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  {
    try {
      result = (int)((Fl_Browser const *)arg1)->size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_size" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser_size" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->size(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser_size", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Browser_size__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Browser_size__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser::size() const\n"
    "    Fl_Browser::size(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_textsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_textsize" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Browser const *)arg1)->textsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_textsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  Fl_Fontsize 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_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_textsize" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->textsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_textsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser_textsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Browser_textsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Browser_textsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser_textsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser::textsize() const\n"
    "    Fl_Browser::textsize(Fl_Fontsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_topline__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_topline" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  {
    try {
      result = (int)((Fl_Browser const *)arg1)->topline(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_lineposition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  int arg2 ;
  Fl_Browser::Fl_Line_Position 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, "Fl_Browser_lineposition", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_lineposition" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_lineposition" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser_lineposition" "', argument " "3"" of type '" "Fl_Browser::Fl_Line_Position""'");
  } 
  arg3 = (Fl_Browser::Fl_Line_Position)(val3);
  {
    try {
      (arg1)->lineposition(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_topline__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_topline" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_topline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->topline(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_topline(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser_topline", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Browser_topline__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Browser_topline__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser_topline'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser::topline() const\n"
    "    Fl_Browser::topline(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_bottomline(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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, "Fl_Browser_bottomline", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_bottomline" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_bottomline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->bottomline(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_middleline(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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, "Fl_Browser_middleline", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_middleline" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_middleline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->middleline(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_select(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  int arg2 ;
  int arg3 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser_select", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_select" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_select" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser_select" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->select(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_selected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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, "Fl_Browser_selected", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_selected" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_selected" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Browser const *)arg1)->selected(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_show__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_show" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_show" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->show(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_show__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_show" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Browser::show();
        } else {
          (arg1)->show();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_show(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser_show", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Browser_show__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Browser_show__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser_show'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser::show(int)\n"
    "    Fl_Browser::show()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_hide__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_hide" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_hide" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->hide(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_hide__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_hide" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Browser::hide();
        } else {
          (arg1)->hide();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_hide(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser_hide", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Browser_hide__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Browser_hide__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser_hide'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser::hide(int)\n"
    "    Fl_Browser::hide()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_visible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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, "Fl_Browser_visible", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_visible" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_visible" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Browser const *)arg1)->visible(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_value" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  {
    try {
      result = (int)((Fl_Browser const *)arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_value" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->value(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser_value", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Browser_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Browser_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser::value() const\n"
    "    Fl_Browser::value(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_text__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_text" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_text" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (char *)((Fl_Browser const *)arg1)->text(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_text__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_text" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_text" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Browser_text" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      (arg1)->text(arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_text(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser_text", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Browser_text__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Browser_text__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser_text'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser::text(int) const\n"
    "    Fl_Browser::text(int,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Fl_Browser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Browser *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Browser", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Browser" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Browser" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Browser" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Browser" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Browser" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Browser *)new SwigDirector_Fl_Browser(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Browser *)new Fl_Browser(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Browser, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Browser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Browser" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_format_char__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_format_char" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  {
    try {
      result = (char)((Fl_Browser const *)arg1)->format_char(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char((char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_format_char__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_format_char" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_format_char" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = (char)(val2);
  {
    try {
      (arg1)->format_char(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_format_char(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser_format_char", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Browser_format_char__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Browser_format_char__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser_format_char'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser::format_char() const\n"
    "    Fl_Browser::format_char(char)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_column_char__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_column_char" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  {
    try {
      result = (char)((Fl_Browser const *)arg1)->column_char(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char((char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_column_char__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_column_char" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_column_char" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = (char)(val2);
  {
    try {
      (arg1)->column_char(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_column_char(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser_column_char", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Browser_column_char__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Browser_column_char__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser_column_char'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser::column_char() const\n"
    "    Fl_Browser::column_char(char)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_column_widths__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_column_widths" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  {
    try {
      result = (int *)((Fl_Browser const *)arg1)->column_widths(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_displayed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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, "Fl_Browser_displayed", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_displayed" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_displayed" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Browser const *)arg1)->displayed(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_make_visible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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, "Fl_Browser_make_visible", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_make_visible" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_make_visible" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->make_visible(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_icon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  int arg2 ;
  Fl_Image *arg3 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_icon" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_icon" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Browser_icon" "', argument " "3"" of type '" "Fl_Image *""'"); 
  }
  arg3 = (Fl_Image *)(argp3);
  {
    try {
      (arg1)->icon(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_icon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_icon" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_icon" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (Fl_Image *)((Fl_Browser const *)arg1)->icon(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_icon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser_icon", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Browser_icon__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Browser_icon__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser_icon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser::icon(int,Fl_Image *)\n"
    "    Fl_Browser::icon(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_remove_icon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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, "Fl_Browser_remove_icon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_remove_icon" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_remove_icon" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->remove_icon(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_replace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser_replace", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_replace" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_replace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Browser_replace" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      (arg1)->replace(arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_display(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  int arg2 ;
  int arg3 = (int) 1 ;
  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, "Fl_Browser_display", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_display" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_display" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser_display" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      (arg1)->display(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 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, "Fl_Browser_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_init_type" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Browser_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Browser_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_add(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  char *arg2 = (char *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser_add", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_add" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Browser_add" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    arg3 = swig_obj[2];
  }
  {
    try {
      Fl_Browser_add(arg1,(char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *arg4 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser_insert", 3, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_insert" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_insert" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Browser_insert" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  if (swig_obj[3]) {
    arg4 = swig_obj[3];
  }
  {
    try {
      Fl_Browser_insert(arg1,arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_get_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser_get_data", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_get_data" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_get_data" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (PyObject *)Fl_Browser_get_data(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  int arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[3] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser_data", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_data" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_data" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (swig_obj[2]) {
    arg3 = swig_obj[2];
  }
  {
    try {
      result = (PyObject *)Fl_Browser_data(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_column_widths__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  PyObject *arg2 = (PyObject *) 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_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_column_widths" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  arg2 = swig_obj[1];
  {
    try {
      Fl_Browser_column_widths__SWIG_1(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_column_widths(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Browser_column_widths", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Browser_column_widths__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Browser_column_widths__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Browser_column_widths'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser::column_widths() const\n"
    "    Fl_Browser::column_widths(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Browser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Browser" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_draw" "', argument " "1"" of type '" "Fl_Browser *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_item_quick_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Browser_item_quick_height", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_item_quick_height" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(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 '" "Fl_Browser_item_quick_height" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_quick_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_quick_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Browser const *)darg)->item_quick_heightSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Browser const *)darg)->item_quick_height(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_full_width(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser_full_width" "', argument " "1"" of type '" "Fl_Browser const *""'"); 
  }
  arg1 = (Fl_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("full_width"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member full_width");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Browser const *)darg)->full_widthSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Browser const *)darg)->full_width();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_File_Browser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_File_Browser *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_File_Browser", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_File_Browser" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_File_Browser" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_File_Browser" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_File_Browser" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_File_Browser" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_File_Browser *)new SwigDirector_Fl_File_Browser(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_File_Browser *)new Fl_File_Browser(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_File_Browser, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_File_Browser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_File_Browser" "', argument " "1"" of type '" "Fl_File_Browser *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_iconsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_iconsize" "', argument " "1"" of type '" "Fl_File_Browser const *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  {
    try {
      result = (uchar)((Fl_File_Browser const *)arg1)->iconsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_iconsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_iconsize" "', argument " "1"" of type '" "Fl_File_Browser *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Browser_iconsize" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  {
    try {
      (arg1)->iconsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_iconsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Browser_iconsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Browser_iconsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Browser_iconsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Browser_iconsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Browser::iconsize() const\n"
    "    Fl_File_Browser::iconsize(uchar)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_filter__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_filter" "', argument " "1"" of type '" "Fl_File_Browser *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_File_Browser_filter" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->filter((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_filter__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_filter" "', argument " "1"" of type '" "Fl_File_Browser const *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  {
    try {
      result = (char *)((Fl_File_Browser const *)arg1)->filter(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_filter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Browser_filter", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Browser_filter__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Browser_filter__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Browser_filter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Browser::filter(char const *)\n"
    "    Fl_File_Browser::filter() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_textsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_textsize" "', argument " "1"" of type '" "Fl_File_Browser const *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_File_Browser const *)arg1)->textsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_textsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  Fl_Fontsize 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_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_textsize" "', argument " "1"" of type '" "Fl_File_Browser *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Browser_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->textsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_textsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Browser_textsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Browser_textsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Browser_textsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Browser_textsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Browser::textsize() const\n"
    "    Fl_File_Browser::textsize(Fl_Fontsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_filetype__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 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_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_filetype" "', argument " "1"" of type '" "Fl_File_Browser const *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  {
    try {
      result = (int)((Fl_File_Browser const *)arg1)->filetype(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_filetype__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 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_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_filetype" "', argument " "1"" of type '" "Fl_File_Browser *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Browser_filetype" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->filetype(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_filetype(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Browser_filetype", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Browser_filetype__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Browser_filetype__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Browser_filetype'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Browser::filetype() const\n"
    "    Fl_File_Browser::filetype(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_errmsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_errmsg" "', argument " "1"" of type '" "Fl_File_Browser *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_File_Browser_errmsg" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->errmsg((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_errmsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_errmsg" "', argument " "1"" of type '" "Fl_File_Browser const *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  {
    try {
      result = (char *)((Fl_File_Browser const *)arg1)->errmsg(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_errmsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Browser_errmsg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Browser_errmsg__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Browser_errmsg__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Browser_errmsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Browser::errmsg(char const *)\n"
    "    Fl_File_Browser::errmsg() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 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, "Fl_File_Browser_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_init_type" "', argument " "1"" of type '" "Fl_File_Browser *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_File_Browser_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_File_Browser_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_load(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Browser_load", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_load" "', argument " "1"" of type '" "Fl_File_Browser *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      result = (int)Fl_File_Browser_load_new(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_File_Browser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_File_Browser" "', argument " "1"" of type '" "Fl_File_Browser *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_draw" "', argument " "1"" of type '" "Fl_File_Browser *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_first(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_item_first" "', argument " "1"" of type '" "Fl_File_Browser const *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_first"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_first");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_File_Browser const *)darg)->item_firstSwigPublic();
        } else {
          result = (void *)((SwigDirector_Fl_File_Browser const *)darg)->item_first();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Browser_item_next", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_item_next" "', argument " "1"" of type '" "Fl_File_Browser const *""'"); 
  }
  arg1 = (Fl_File_Browser *)(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 '" "Fl_File_Browser_item_next" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_next"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_next");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_File_Browser const *)darg)->item_nextSwigPublic(arg2);
        } else {
          result = (void *)((SwigDirector_Fl_File_Browser const *)darg)->item_next(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_prev(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Browser_item_prev", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_item_prev" "', argument " "1"" of type '" "Fl_File_Browser const *""'"); 
  }
  arg1 = (Fl_File_Browser *)(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 '" "Fl_File_Browser_item_prev" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_prev"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_prev");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_File_Browser const *)darg)->item_prevSwigPublic(arg2);
        } else {
          result = (void *)((SwigDirector_Fl_File_Browser const *)darg)->item_prev(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_last(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_item_last" "', argument " "1"" of type '" "Fl_File_Browser const *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_last"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_last");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_File_Browser const *)darg)->item_lastSwigPublic();
        } else {
          result = (void *)((SwigDirector_Fl_File_Browser const *)darg)->item_last();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Browser_item_height", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_item_height" "', argument " "1"" of type '" "Fl_File_Browser const *""'"); 
  }
  arg1 = (Fl_File_Browser *)(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 '" "Fl_File_Browser_item_height" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_File_Browser const *)darg)->item_heightSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_File_Browser const *)darg)->item_height(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_width(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Browser_item_width", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_item_width" "', argument " "1"" of type '" "Fl_File_Browser const *""'"); 
  }
  arg1 = (Fl_File_Browser *)(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 '" "Fl_File_Browser_item_width" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_width"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_width");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_File_Browser const *)darg)->item_widthSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_File_Browser const *)darg)->item_width(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_quick_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Browser_item_quick_height", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_item_quick_height" "', argument " "1"" of type '" "Fl_File_Browser const *""'"); 
  }
  arg1 = (Fl_File_Browser *)(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 '" "Fl_File_Browser_item_quick_height" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_quick_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_quick_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_File_Browser const *)darg)->item_quick_heightSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_File_Browser const *)darg)->item_quick_height(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Browser_item_draw", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_item_draw" "', argument " "1"" of type '" "Fl_File_Browser const *""'"); 
  }
  arg1 = (Fl_File_Browser *)(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 '" "Fl_File_Browser_item_draw" "', 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 '" "Fl_File_Browser_item_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_File_Browser_item_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_File_Browser_item_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_File_Browser_item_draw" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    {
      try {
        if (upcall) {
          ((SwigDirector_Fl_File_Browser const *)darg)->item_drawSwigPublic(arg2,arg3,arg4,arg5,arg6);
        } else {
          ((SwigDirector_Fl_File_Browser const *)darg)->item_draw(arg2,arg3,arg4,arg5,arg6);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_text(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Browser_item_text", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_item_text" "', argument " "1"" of type '" "Fl_File_Browser const *""'"); 
  }
  arg1 = (Fl_File_Browser *)(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 '" "Fl_File_Browser_item_text" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_text"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_text");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (char *)((SwigDirector_Fl_File_Browser const *)darg)->item_textSwigPublic(arg2);
        } else {
          result = (char *)((SwigDirector_Fl_File_Browser const *)darg)->item_text(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (director) {
    director->swig_release_ownership(SWIG_as_voidptr(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Browser_item_swap", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_item_swap" "', argument " "1"" of type '" "Fl_File_Browser *""'"); 
  }
  arg1 = (Fl_File_Browser *)(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 '" "Fl_File_Browser_item_swap" "', argument " "2"" of type '" "void *""'"); 
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_File_Browser_item_swap" "', argument " "3"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_swap"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_swap");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->item_swapSwigPublic(arg2,arg3);
        } else {
          (darg)->item_swap(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_at(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Browser_item_at", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_item_at" "', argument " "1"" of type '" "Fl_File_Browser const *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Browser_item_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_at"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_at");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_File_Browser const *)darg)->item_atSwigPublic(arg2);
        } else {
          result = (void *)((SwigDirector_Fl_File_Browser const *)darg)->item_at(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_full_width(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_full_width" "', argument " "1"" of type '" "Fl_File_Browser const *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("full_width"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member full_width");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_File_Browser const *)darg)->full_widthSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_File_Browser const *)darg)->full_width();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_full_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_full_height" "', argument " "1"" of type '" "Fl_File_Browser const *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("full_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member full_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_File_Browser const *)darg)->full_heightSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_File_Browser const *)darg)->full_height();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_incr_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_incr_height" "', argument " "1"" of type '" "Fl_File_Browser const *""'"); 
  }
  arg1 = (Fl_File_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("incr_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member incr_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_File_Browser const *)darg)->incr_heightSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_File_Browser const *)darg)->incr_height();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_select(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Browser_item_select", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_item_select" "', argument " "1"" of type '" "Fl_File_Browser *""'"); 
  }
  arg1 = (Fl_File_Browser *)(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 '" "Fl_File_Browser_item_select" "', 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 '" "Fl_File_Browser_item_select" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_select"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_select");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->item_selectSwigPublic(arg2,arg3);
        } else {
          (darg)->item_select(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_selected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Browser_item_selected", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Browser_item_selected" "', argument " "1"" of type '" "Fl_File_Browser const *""'"); 
  }
  arg1 = (Fl_File_Browser *)(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 '" "Fl_File_Browser_item_selected" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_selected"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_selected");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_File_Browser const *)darg)->item_selectedSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_File_Browser const *)darg)->item_selected(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_File_Icon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int arg3 = (int) 0 ;
  short *arg4 = (short *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  Fl_File_Icon *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_File_Icon", 2, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fl_File_Icon" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_File_Icon" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_File_Icon" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  if (swig_obj[3]) {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_short, 0 |  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Fl_File_Icon" "', argument " "4"" of type '" "short *""'"); 
    }
    arg4 = (short *)(argp4);
  }
  {
    try {
      result = (Fl_File_Icon *)new Fl_File_Icon((char const *)arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_File_Icon, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_File_Icon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Icon, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_File_Icon" "', argument " "1"" of type '" "Fl_File_Icon *""'"); 
  }
  arg1 = (Fl_File_Icon *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_add(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  short *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Icon_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Icon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Icon_add" "', argument " "1"" of type '" "Fl_File_Icon *""'"); 
  }
  arg1 = (Fl_File_Icon *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Icon_add" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = (short)(val2);
  {
    try {
      result = (short *)(arg1)->add(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_add_color(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  short *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Icon_add_color", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Icon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Icon_add_color" "', argument " "1"" of type '" "Fl_File_Icon *""'"); 
  }
  arg1 = (Fl_File_Icon *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Icon_add_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      result = (short *)(arg1)->add_color(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_add_vertex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  short *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Icon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Icon_add_vertex" "', argument " "1"" of type '" "Fl_File_Icon *""'"); 
  }
  arg1 = (Fl_File_Icon *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Icon_add_vertex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_File_Icon_add_vertex" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (short *)(arg1)->add_vertex(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_add_vertex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 0 ;
  float arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  short *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Icon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Icon_add_vertex" "', argument " "1"" of type '" "Fl_File_Icon *""'"); 
  }
  arg1 = (Fl_File_Icon *)(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Icon_add_vertex" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = (float)(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_File_Icon_add_vertex" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = (float)(val3);
  {
    try {
      result = (short *)(arg1)->add_vertex(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_add_vertex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Icon_add_vertex", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Fl_File_Icon_add_vertex__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_File_Icon_add_vertex__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Icon_add_vertex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Icon::add_vertex(int,int)\n"
    "    Fl_File_Icon::add_vertex(float,float)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Icon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Icon_clear" "', argument " "1"" of type '" "Fl_File_Icon *""'"); 
  }
  arg1 = (Fl_File_Icon *)(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  Fl_Color arg6 ;
  int arg7 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Icon_draw", 6, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Icon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Icon_draw" "', argument " "1"" of type '" "Fl_File_Icon *""'"); 
  }
  arg1 = (Fl_File_Icon *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Icon_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_File_Icon_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_File_Icon_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_File_Icon_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_File_Icon_draw" "', argument " "6"" of type '" "Fl_Color""'");
  } 
  arg6 = (Fl_Color)(val6);
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_File_Icon_draw" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  {
    try {
      (arg1)->draw(arg2,arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_label(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Icon_label", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Icon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Icon_label" "', argument " "1"" of type '" "Fl_File_Icon *""'"); 
  }
  arg1 = (Fl_File_Icon *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_File_Icon_label" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  {
    try {
      (arg1)->label(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_labeltype(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Label *arg1 = (Fl_Label *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  Fl_Align arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Icon_labeltype", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Label, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Icon_labeltype" "', argument " "1"" of type '" "Fl_Label const *""'"); 
  }
  arg1 = (Fl_Label *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Icon_labeltype" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_File_Icon_labeltype" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_File_Icon_labeltype" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_File_Icon_labeltype" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_File_Icon_labeltype" "', argument " "6"" of type '" "Fl_Align""'");
  } 
  arg6 = (Fl_Align)(val6);
  {
    try {
      Fl_File_Icon::labeltype((Fl_Label const *)arg1,arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_load(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 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, "Fl_File_Icon_load", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Icon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Icon_load" "', argument " "1"" of type '" "Fl_File_Icon *""'"); 
  }
  arg1 = (Fl_File_Icon *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_File_Icon_load" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->load((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_load_fti(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 0 ;
  char *arg2 = (char *) 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, "Fl_File_Icon_load_fti", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Icon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Icon_load_fti" "', argument " "1"" of type '" "Fl_File_Icon *""'"); 
  }
  arg1 = (Fl_File_Icon *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_File_Icon_load_fti" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)(arg1)->load_fti((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_load_image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 0 ;
  char *arg2 = (char *) 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, "Fl_File_Icon_load_image", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Icon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Icon_load_image" "', argument " "1"" of type '" "Fl_File_Icon *""'"); 
  }
  arg1 = (Fl_File_Icon *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_File_Icon_load_image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)(arg1)->load_image((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_File_Icon *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Icon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Icon_next" "', argument " "1"" of type '" "Fl_File_Icon *""'"); 
  }
  arg1 = (Fl_File_Icon *)(argp1);
  {
    try {
      result = (Fl_File_Icon *)(arg1)->next(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_File_Icon, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_pattern(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 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_Fl_File_Icon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Icon_pattern" "', argument " "1"" of type '" "Fl_File_Icon *""'"); 
  }
  arg1 = (Fl_File_Icon *)(argp1);
  {
    try {
      result = (char *)(arg1)->pattern(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 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_Fl_File_Icon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Icon_size" "', argument " "1"" of type '" "Fl_File_Icon *""'"); 
  }
  arg1 = (Fl_File_Icon *)(argp1);
  {
    try {
      result = (int)(arg1)->size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 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_Fl_File_Icon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Icon_type" "', argument " "1"" of type '" "Fl_File_Icon *""'"); 
  }
  arg1 = (Fl_File_Icon *)(argp1);
  {
    try {
      result = (int)(arg1)->type(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  short *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Icon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Icon_value" "', argument " "1"" of type '" "Fl_File_Icon *""'"); 
  }
  arg1 = (Fl_File_Icon *)(argp1);
  {
    try {
      result = (short *)(arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 = (int) Fl_File_Icon::ANY ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Fl_File_Icon *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Icon_find", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Icon_find" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Icon_find" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      result = (Fl_File_Icon *)Fl_File_Icon::find((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_File_Icon, 0 |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_first(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Icon_first", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_File_Icon *)Fl_File_Icon::first(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_File_Icon, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_load_system_icons(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Icon_load_system_icons", 0, 0, 0)) SWIG_fail;
  {
    try {
      Fl_File_Icon::load_system_icons(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_File_Chooser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  char *arg4 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  PyObject *swig_obj[4] ;
  Fl_File_Chooser *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_File_Chooser", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fl_File_Chooser" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_File_Chooser" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_File_Chooser" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Fl_File_Chooser" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = (char *)(buf4);
  {
    try {
      result = (Fl_File_Chooser *)new Fl_File_Chooser((char const *)arg1,(char const *)arg2,arg3,(char const *)arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_File_Chooser, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_File_Chooser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_File_Chooser" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_callback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void (*arg2)(Fl_File_Chooser *,void *) = (void (*)(Fl_File_Chooser *,void *)) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_callback" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_Fl_File_Chooser_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_File_Chooser_callback" "', argument " "2"" of type '" "void (*)(Fl_File_Chooser *,void *)""'"); 
    }
  }
  if (swig_obj[2]) {
    res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_File_Chooser_callback" "', argument " "3"" of type '" "void *""'"); 
    }
  }
  {
    try {
      (arg1)->callback(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_color" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->color(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_color" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (Fl_Color)(arg1)->color(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Chooser_color", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Chooser_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Chooser_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Chooser_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Chooser::color(Fl_Color)\n"
    "    Fl_File_Chooser::color()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 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_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_count" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (int)(arg1)->count(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_directory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_directory" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_File_Chooser_directory" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->directory((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_directory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_directory" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (char *)(arg1)->directory(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_directory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Chooser_directory", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Chooser_directory__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Chooser_directory__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Chooser_directory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Chooser::directory(char const *)\n"
    "    Fl_File_Chooser::directory()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_filter__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_filter" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_File_Chooser_filter" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->filter((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_filter__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_filter" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (char *)(arg1)->filter(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_filter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Chooser_filter", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Chooser_filter__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Chooser_filter__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Chooser_filter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Chooser::filter(char const *)\n"
    "    Fl_File_Chooser::filter()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_filter_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 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_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_filter_value" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (int)(arg1)->filter_value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_filter_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 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_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_filter_value" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_filter_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->filter_value(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_filter_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Chooser_filter_value", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Chooser_filter_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Chooser_filter_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Chooser_filter_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Chooser::filter_value()\n"
    "    Fl_File_Chooser::filter_value(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_iconsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_iconsize" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_iconsize" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  {
    try {
      (arg1)->iconsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_iconsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_iconsize" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (uchar)(arg1)->iconsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_iconsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Chooser_iconsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Chooser_iconsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Chooser_iconsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Chooser_iconsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Chooser::iconsize(uchar)\n"
    "    Fl_File_Chooser::iconsize()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_label__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_label" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_File_Chooser_label" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->label((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_label__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_label" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (char *)(arg1)->label(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_label(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Chooser_label", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Chooser_label__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Chooser_label__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Chooser_label'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Chooser::label(char const *)\n"
    "    Fl_File_Chooser::label()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_ok_label__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_ok_label" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_File_Chooser_ok_label" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->ok_label((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_ok_label__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_ok_label" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (char *)(arg1)->ok_label(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_ok_label(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Chooser_ok_label", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Chooser_ok_label__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Chooser_ok_label__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Chooser_ok_label'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Chooser::ok_label(char const *)\n"
    "    Fl_File_Chooser::ok_label()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_preview__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 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_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_preview" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_preview" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->preview(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_preview__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 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_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_preview" "', argument " "1"" of type '" "Fl_File_Chooser const *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (int)((Fl_File_Chooser const *)arg1)->preview(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_preview(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Chooser_preview", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Chooser_preview__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Chooser_preview__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Chooser_preview'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Chooser::preview(int)\n"
    "    Fl_File_Chooser::preview() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_rescan(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_rescan" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      (arg1)->rescan(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_show(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_show" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      (arg1)->show(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_hide(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_hide" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      (arg1)->hide(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_shown(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 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_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_shown" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (int)(arg1)->shown(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_textcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_textcolor" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->textcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_textcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_textcolor" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (Fl_Color)(arg1)->textcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_textcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Chooser_textcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Chooser_textcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Chooser_textcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Chooser_textcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Chooser::textcolor(Fl_Color)\n"
    "    Fl_File_Chooser::textcolor()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_textfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  Fl_Font 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_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_textfont" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->textfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_textfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_textfont" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (Fl_Font)(arg1)->textfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_textfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Chooser_textfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Chooser_textfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Chooser_textfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Chooser_textfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Chooser::textfont(Fl_Font)\n"
    "    Fl_File_Chooser::textfont()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_textsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  Fl_Fontsize 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_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_textsize" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->textsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_textsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_textsize" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (Fl_Fontsize)(arg1)->textsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_textsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Chooser_textsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Chooser_textsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Chooser_textsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Chooser_textsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Chooser::textsize(Fl_Fontsize)\n"
    "    Fl_File_Chooser::textsize()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_type__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 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_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_type" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_type" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->type(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_type__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 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_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_type" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (int)(arg1)->type(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_type(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Chooser_type", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Chooser_type__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Chooser_type__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Chooser_type'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Chooser::type(int)\n"
    "    Fl_File_Chooser::type()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  int arg2 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_value" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_value" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      result = (char *)(arg1)->value(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_value" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_File_Chooser_value" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->value((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Chooser_value", 0, 2, argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v = 0;
    if (argc > 1) {
      {
        {
          int res = SWIG_AsVal_int(argv[1], NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (!_v) goto check_1;
    }
    return _wrap_Fl_File_Chooser_value__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Chooser_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Chooser_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Chooser::value(int)\n"
    "    Fl_File_Chooser::value(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_visible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 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_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_visible" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (int)(arg1)->visible(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_position(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 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, "Fl_File_Chooser_position", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_position" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_position" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_File_Chooser_position" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->position(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_x(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 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_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_x" "', argument " "1"" of type '" "Fl_File_Chooser const *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (int)((Fl_File_Chooser const *)arg1)->x(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_y(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 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_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_y" "', argument " "1"" of type '" "Fl_File_Chooser const *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (int)((Fl_File_Chooser const *)arg1)->y(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 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_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_w" "', argument " "1"" of type '" "Fl_File_Chooser const *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (int)((Fl_File_Chooser const *)arg1)->w(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 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_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_h" "', argument " "1"" of type '" "Fl_File_Chooser const *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (int)((Fl_File_Chooser const *)arg1)->h(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 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, "Fl_File_Chooser_size", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_size" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_File_Chooser_size" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->size(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Chooser_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_resize" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_File_Chooser_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_File_Chooser_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_File_Chooser_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      (arg1)->resize(arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_add_extra(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Chooser_add_extra", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_add_extra" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_File_Chooser_add_extra" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  {
    try {
      result = (Fl_Widget *)(arg1)->add_extra(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Widget, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_callback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  PyObject *arg4 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_callback" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(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];
  if (swig_obj[3]) {
    arg4 = swig_obj[3];
  }
  {
    try {
      Fl_File_Chooser_callback__SWIG_1(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_callback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Chooser_callback", 0, 4, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_Fl_File_Chooser_p_void__void);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    if (argc > 2) {
      {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
      }
      if (!_v) goto check_1;
    }
    return _wrap_Fl_File_Chooser_callback__SWIG_0(self, argc, argv);
  }
check_1:
  
  if ((argc >= 3) && (argc <= 4)) {
    PyObject *retobj = _wrap_Fl_File_Chooser_callback__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Chooser_callback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Chooser::callback(void (*)(Fl_File_Chooser *,void *),void *)\n"
    "    Fl_File_Chooser::callback(PyObject *,PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_user_data__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  PyObject *arg2 = (PyObject *) 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_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_user_data" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  arg2 = swig_obj[1];
  {
    try {
      Fl_File_Chooser_user_data__SWIG_0(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_user_data__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Chooser_user_data" "', argument " "1"" of type '" "Fl_File_Chooser *""'"); 
  }
  arg1 = (Fl_File_Chooser *)(argp1);
  {
    try {
      result = (PyObject *)Fl_File_Chooser_user_data__SWIG_1(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_user_data(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Chooser_user_data", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Chooser_user_data__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Chooser_user_data__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Chooser_user_data'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Chooser::user_data(PyObject *)\n"
    "    Fl_File_Chooser::user_data()\n");
  return 0;
}


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

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

SWIGINTERN PyObject *_wrap_fl_dir_chooser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 = (int) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_dir_chooser", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_dir_chooser" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_dir_chooser" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_dir_chooser" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (char *)fl_dir_chooser((char const *)arg1,(char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_file_chooser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 = (int) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_file_chooser", 3, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_file_chooser" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_file_chooser" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_file_chooser" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_file_chooser" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  {
    try {
      result = (char *)fl_file_chooser((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_file_chooser_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void (*arg1)(char const *) = (void (*)(char const *)) 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "fl_file_chooser_callback" "', argument " "1"" of type '" "void (*)(char const *)""'"); 
    }
  }
  {
    try {
      fl_file_chooser_callback(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_file_chooser_ok_label(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_file_chooser_ok_label" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      fl_file_chooser_ok_label((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_screen_driver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Screen_Driver *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "screen_driver", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Screen_Driver *)Fl::screen_driver(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Screen_Driver, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_system_driver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_System_Driver *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "system_driver", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_System_Driver *)Fl::system_driver(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_System_Driver, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_box_shadow_width__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::box_shadow_width(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_box_shadow_width__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 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 '" "box_shadow_width" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      Fl::box_shadow_width(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_box_shadow_width(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "box_shadow_width", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_box_shadow_width__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_box_shadow_width__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'box_shadow_width'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::box_shadow_width()\n"
    "    Fl::box_shadow_width(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_box_border_radius_max__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::box_border_radius_max(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_box_border_radius_max__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 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 '" "box_border_radius_max" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      Fl::box_border_radius_max(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_box_border_radius_max(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "box_border_radius_max", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_box_border_radius_max__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_box_border_radius_max__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'box_border_radius_max'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::box_border_radius_max()\n"
    "    Fl::box_border_radius_max(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_call_screen_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "call_screen_init", 0, 0, 0)) SWIG_fail;
  {
    try {
      Fl::call_screen_init(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_damage__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 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 '" "damage" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      Fl::damage(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_idle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "idle", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (bool)Fl::idle(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_version(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "version", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (double)Fl::version(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_api_version(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "api_version", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::api_version(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_abi_version(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "abi_version", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::abi_version(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_abi_check(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 = (int) (int)FL_ABI_VERSION ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "abi_check", 0, 1, swig_obj)) SWIG_fail;
  if (swig_obj[0]) {
    ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "abi_check" "', argument " "1"" of type '" "int""'");
    } 
    arg1 = (int)(val1);
  }
  {
    try {
      result = (int)Fl::abi_check(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_arg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  char **arg2 = (char **) 0 ;
  int *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "arg", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "arg" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  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 '" "arg" "', argument " "2"" of type '" "char **""'"); 
  }
  arg2 = (char **)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "arg" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "arg" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = (int *)(argp3);
  {
    try {
      result = (int)Fl::arg(arg1,arg2,*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_args__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  char **arg2 = (char **) 0 ;
  int *arg3 = 0 ;
  Fl_Args_Handler arg4 = (Fl_Args_Handler) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "args" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  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 '" "args" "', argument " "2"" of type '" "char **""'"); 
  }
  arg2 = (char **)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "args" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "args" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = (int *)(argp3);
  if (swig_obj[3]) {
    {
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Fl_Args_Handler,  0  | 0);
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "args" "', argument " "4"" of type '" "Fl_Args_Handler""'"); 
      }  
      if (!argp4) {
        SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "args" "', argument " "4"" of type '" "Fl_Args_Handler""'");
      } else {
        Fl_Args_Handler * temp = (Fl_Args_Handler *)(argp4);
        arg4 = *temp;
        if (SWIG_IsNewObj(res4)) delete temp;
      }
    }
  }
  {
    try {
      result = (int)Fl::args(arg1,arg2,*arg3,SWIG_STD_MOVE(arg4)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_args__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  char **arg2 = (char **) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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 '" "args" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  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 '" "args" "', argument " "2"" of type '" "char **""'"); 
  }
  arg2 = (char **)(argp2);
  {
    try {
      Fl::args(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_args(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "args", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_args__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 3) && (argc <= 4)) {
    PyObject *retobj = _wrap_args__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'args'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::args(int,char **,int &,Fl_Args_Handler)\n"
    "    Fl::args(int,char **)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_display(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "display" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      Fl::display((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_visual(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "visual" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      result = (int)Fl::visual(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_own_colormap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "own_colormap", 0, 0, 0)) SWIG_fail;
  {
    try {
      Fl::own_colormap(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_system_colors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "get_system_colors", 0, 0, 0)) SWIG_fail;
  {
    try {
      Fl::get_system_colors(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_foreground(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uchar arg1 ;
  uchar arg2 ;
  uchar arg3 ;
  unsigned char val1 ;
  int ecode1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "foreground", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "foreground" "', argument " "1"" of type '" "uchar""'");
  } 
  arg1 = (uchar)(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "foreground" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "foreground" "', argument " "3"" of type '" "uchar""'");
  } 
  arg3 = (uchar)(val3);
  {
    try {
      Fl::foreground(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_background(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uchar arg1 ;
  uchar arg2 ;
  uchar arg3 ;
  unsigned char val1 ;
  int ecode1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "background", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "background" "', argument " "1"" of type '" "uchar""'");
  } 
  arg1 = (uchar)(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "background" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "background" "', argument " "3"" of type '" "uchar""'");
  } 
  arg3 = (uchar)(val3);
  {
    try {
      Fl::background(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_background2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uchar arg1 ;
  uchar arg2 ;
  uchar arg3 ;
  unsigned char val1 ;
  int ecode1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "background2", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "background2" "', argument " "1"" of type '" "uchar""'");
  } 
  arg1 = (uchar)(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "background2" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "background2" "', argument " "3"" of type '" "uchar""'");
  } 
  arg3 = (uchar)(val3);
  {
    try {
      Fl::background2(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scheme__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int 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 '" "scheme" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (int)Fl::scheme((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_scheme__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (char *)Fl::scheme(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scheme(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "scheme", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_scheme__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_scheme__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'scheme'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::scheme(char const *)\n"
    "    Fl::scheme()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_is_scheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_scheme" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (int)Fl::is_scheme((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reload_scheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "reload_scheme", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::reload_scheme(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scrollbar_size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::scrollbar_size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scrollbar_size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 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 '" "scrollbar_size" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      Fl::scrollbar_size(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scrollbar_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "scrollbar_size", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_scrollbar_size__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_scrollbar_size__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'scrollbar_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::scrollbar_size()\n"
    "    Fl::scrollbar_size(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_menu_linespacing__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::menu_linespacing(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_menu_linespacing__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 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 '" "menu_linespacing" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      Fl::menu_linespacing(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_menu_linespacing(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "menu_linespacing", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_menu_linespacing__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_menu_linespacing__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'menu_linespacing'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::menu_linespacing()\n"
    "    Fl::menu_linespacing(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_wait__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::wait(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_wait__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  double result;
  
  (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 '" "wait" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  {
    try {
      result = (double)Fl::wait(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_wait(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "wait", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_wait__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_wait__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'wait'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::wait()\n"
    "    Fl::wait(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_check(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "check", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::check(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ready(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ready", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::ready(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_run(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "run", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::run(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_program_should_quit__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::program_should_quit(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_program_should_quit__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 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 '" "program_should_quit" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      Fl::program_should_quit(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_program_should_quit(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "program_should_quit", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_program_should_quit__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_program_should_quit__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'program_should_quit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::program_should_quit()\n"
    "    Fl::program_should_quit(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_hide_all_windows(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "hide_all_windows", 0, 0, 0)) SWIG_fail;
  {
    try {
      Fl::hide_all_windows(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_readqueue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "readqueue", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Widget *)Fl::readqueue(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Widget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_has_timeout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Timeout_Handler arg1 ;
  void *arg2 = (void *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "has_timeout", 1, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Timeout_Handler,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "has_timeout" "', argument " "1"" of type '" "Fl_Timeout_Handler""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "has_timeout" "', argument " "1"" of type '" "Fl_Timeout_Handler""'");
    } else {
      Fl_Timeout_Handler * temp = (Fl_Timeout_Handler *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "has_timeout" "', argument " "2"" of type '" "void *""'"); 
    }
  }
  {
    try {
      result = (int)Fl::has_timeout(SWIG_STD_MOVE(arg1),arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_remove_next_timeout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Timeout_Handler arg1 ;
  void *arg2 = (void *) 0 ;
  void **arg3 = (void **) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "remove_next_timeout", 1, 3, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Timeout_Handler,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "remove_next_timeout" "', argument " "1"" of type '" "Fl_Timeout_Handler""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "remove_next_timeout" "', argument " "1"" of type '" "Fl_Timeout_Handler""'");
    } else {
      Fl_Timeout_Handler * temp = (Fl_Timeout_Handler *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "remove_next_timeout" "', argument " "2"" of type '" "void *""'"); 
    }
  }
  if (swig_obj[2]) {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_void, 0 |  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "remove_next_timeout" "', argument " "3"" of type '" "void **""'"); 
    }
    arg3 = (void **)(argp3);
  }
  {
    try {
      result = (int)Fl::remove_next_timeout(SWIG_STD_MOVE(arg1),arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeoutData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl::TimeoutData *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_TimeoutData", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl::TimeoutData *)new Fl::TimeoutData(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl__TimeoutData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TimeoutData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl::TimeoutData *arg1 = (Fl::TimeoutData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl__TimeoutData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeoutData" "', argument " "1"" of type '" "Fl::TimeoutData *""'"); 
  }
  arg1 = (Fl::TimeoutData *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_timeout_list(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< Fl::TimeoutData > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "timeout_list", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = Fl::timeout_list(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< Fl::TimeoutData >(result)), SWIGTYPE_p_std__vectorT_Fl__TimeoutData_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_now(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 = (double) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Timestamp result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "now", 0, 1, swig_obj)) SWIG_fail;
  if (swig_obj[0]) {
    ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "now" "', argument " "1"" of type '" "double""'");
    } 
    arg1 = (double)(val1);
  }
  {
    try {
      result = Fl::now(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new Fl_Timestamp(result)), SWIGTYPE_p_Fl_Timestamp, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_seconds_since(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Timestamp *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_Fl_Timestamp,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "seconds_since" "', argument " "1"" of type '" "Fl_Timestamp &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "seconds_since" "', argument " "1"" of type '" "Fl_Timestamp &""'"); 
  }
  arg1 = (Fl_Timestamp *)(argp1);
  {
    try {
      result = (double)Fl::seconds_since(*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_seconds_between(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Timestamp *arg1 = 0 ;
  Fl_Timestamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "seconds_between", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Timestamp,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "seconds_between" "', argument " "1"" of type '" "Fl_Timestamp &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "seconds_between" "', argument " "1"" of type '" "Fl_Timestamp &""'"); 
  }
  arg1 = (Fl_Timestamp *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Timestamp,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "seconds_between" "', argument " "2"" of type '" "Fl_Timestamp &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "seconds_between" "', argument " "2"" of type '" "Fl_Timestamp &""'"); 
  }
  arg2 = (Fl_Timestamp *)(argp2);
  {
    try {
      result = (double)Fl::seconds_between(*arg1,*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ticks_since(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Timestamp *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_Fl_Timestamp,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ticks_since" "', argument " "1"" of type '" "Fl_Timestamp &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ticks_since" "', argument " "1"" of type '" "Fl_Timestamp &""'"); 
  }
  arg1 = (Fl_Timestamp *)(argp1);
  {
    try {
      result = (long)Fl::ticks_since(*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long((long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ticks_between(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Timestamp *arg1 = 0 ;
  Fl_Timestamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  long result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ticks_between", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Timestamp,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ticks_between" "', argument " "1"" of type '" "Fl_Timestamp &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ticks_between" "', argument " "1"" of type '" "Fl_Timestamp &""'"); 
  }
  arg1 = (Fl_Timestamp *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Timestamp,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ticks_between" "', argument " "2"" of type '" "Fl_Timestamp &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ticks_between" "', argument " "2"" of type '" "Fl_Timestamp &""'"); 
  }
  arg2 = (Fl_Timestamp *)(argp2);
  {
    try {
      result = (long)Fl::ticks_between(*arg1,*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long((long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_add_idle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Idle_Handler arg1 ;
  void *arg2 = (void *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Idle_Handler,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "add_idle" "', argument " "1"" of type '" "Fl_Idle_Handler""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "add_idle" "', argument " "1"" of type '" "Fl_Idle_Handler""'");
    } else {
      Fl_Idle_Handler * temp = (Fl_Idle_Handler *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "add_idle" "', argument " "2"" of type '" "void *""'"); 
    }
  }
  {
    try {
      Fl::add_idle(SWIG_STD_MOVE(arg1),arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_has_idle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Idle_Handler arg1 ;
  void *arg2 = (void *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "has_idle", 1, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Idle_Handler,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "has_idle" "', argument " "1"" of type '" "Fl_Idle_Handler""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "has_idle" "', argument " "1"" of type '" "Fl_Idle_Handler""'");
    } else {
      Fl_Idle_Handler * temp = (Fl_Idle_Handler *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "has_idle" "', argument " "2"" of type '" "void *""'"); 
    }
  }
  {
    try {
      result = (int)Fl::has_idle(SWIG_STD_MOVE(arg1),arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_remove_idle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Idle_Handler arg1 ;
  void *arg2 = (void *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "remove_idle", 1, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Idle_Handler,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "remove_idle" "', argument " "1"" of type '" "Fl_Idle_Handler""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "remove_idle" "', argument " "1"" of type '" "Fl_Idle_Handler""'");
    } else {
      Fl_Idle_Handler * temp = (Fl_Idle_Handler *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "remove_idle" "', argument " "2"" of type '" "void *""'"); 
    }
  }
  {
    try {
      Fl::remove_idle(SWIG_STD_MOVE(arg1),arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_add_idle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Old_Idle_Handler arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Old_Idle_Handler,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "add_idle" "', argument " "1"" of type '" "Fl_Old_Idle_Handler""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "add_idle" "', argument " "1"" of type '" "Fl_Old_Idle_Handler""'");
    } else {
      Fl_Old_Idle_Handler * temp = (Fl_Old_Idle_Handler *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      Fl::add_idle(SWIG_STD_MOVE(arg1)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_add_idle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "add_idle", 0, 2, argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Fl_Idle_Handler, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_add_idle__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_add_idle__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'add_idle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::add_idle(Fl_Idle_Handler,void *)\n"
    "    Fl::add_idle(Fl_Old_Idle_Handler)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_damage__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::damage(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_damage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "damage", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_damage__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_damage__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'damage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::damage(int)\n"
    "    Fl::damage()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_redraw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "redraw", 0, 0, 0)) SWIG_fail;
  {
    try {
      Fl::redraw(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_flush(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "flush", 0, 0, 0)) SWIG_fail;
  {
    try {
      Fl::flush(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_first_window__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Fl_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Fl_Window *)Fl::first_window(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_first_window__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 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_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "first_window" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      Fl::first_window(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_first_window(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "first_window", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_first_window__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_first_window__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'first_window'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::first_window()\n"
    "    Fl::first_window(Fl_Window *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_next_window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Window *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "next_window" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (Fl_Window *)Fl::next_window((Fl_Window const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_modal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "modal", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Window *)Fl::modal(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_grab__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Fl_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Fl_Window *)Fl::grab(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_grab__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 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_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "grab" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      Fl::grab(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_grab(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "grab", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_grab__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_grab__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'grab'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::grab()\n"
    "    Fl::grab(Fl_Window *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int arg3 = (int) 0 ;
  char *arg4 = (char *) Fl::clipboard_plain_text ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "copy", 2, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copy" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  if (swig_obj[3]) {
    res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "copy" "', argument " "4"" of type '" "char const *""'");
    }
    arg4 = (char *)(buf4);
  }
  {
    try {
      Fl::copy((char const *)arg1,arg2,arg3,(char const *)arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_selection_to_clipboard__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 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 '" "selection_to_clipboard" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      Fl::selection_to_clipboard(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_selection_to_clipboard__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::selection_to_clipboard(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_selection_to_clipboard(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "selection_to_clipboard", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_selection_to_clipboard__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_selection_to_clipboard__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'selection_to_clipboard'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::selection_to_clipboard(int)\n"
    "    Fl::selection_to_clipboard()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_paste__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = 0 ;
  int arg2 ;
  char *arg3 = (char *) Fl::clipboard_plain_text ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Widget,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "paste" "', argument " "1"" of type '" "Fl_Widget &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "paste" "', argument " "1"" of type '" "Fl_Widget &""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "paste" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (swig_obj[2]) {
    res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "paste" "', argument " "3"" of type '" "char const *""'");
    }
    arg3 = (char *)(buf3);
  }
  {
    try {
      Fl::paste(*arg1,arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_add_clipboard_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clipboard_Notify_Handler arg1 ;
  void *arg2 = (void *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "add_clipboard_notify", 1, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Clipboard_Notify_Handler,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "add_clipboard_notify" "', argument " "1"" of type '" "Fl_Clipboard_Notify_Handler""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "add_clipboard_notify" "', argument " "1"" of type '" "Fl_Clipboard_Notify_Handler""'");
    } else {
      Fl_Clipboard_Notify_Handler * temp = (Fl_Clipboard_Notify_Handler *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "add_clipboard_notify" "', argument " "2"" of type '" "void *""'"); 
    }
  }
  {
    try {
      Fl::add_clipboard_notify(SWIG_STD_MOVE(arg1),arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_remove_clipboard_notify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clipboard_Notify_Handler arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Clipboard_Notify_Handler,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "remove_clipboard_notify" "', argument " "1"" of type '" "Fl_Clipboard_Notify_Handler""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "remove_clipboard_notify" "', argument " "1"" of type '" "Fl_Clipboard_Notify_Handler""'");
    } else {
      Fl_Clipboard_Notify_Handler * temp = (Fl_Clipboard_Notify_Handler *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      Fl::remove_clipboard_notify(SWIG_STD_MOVE(arg1)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_clipboard_contains(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clipboard_contains" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (int)Fl::clipboard_contains((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dnd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "dnd", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::dnd(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_selection_owner__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Fl_Widget *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Fl_Widget *)Fl::selection_owner(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Widget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_selection_owner__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selection_owner" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      Fl::selection_owner(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_selection_owner(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "selection_owner", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_selection_owner__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_selection_owner__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'selection_owner'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::selection_owner()\n"
    "    Fl::selection_owner(Fl_Widget *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_selection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "selection", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Widget,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selection" "', argument " "1"" of type '" "Fl_Widget &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "selection" "', argument " "1"" of type '" "Fl_Widget &""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "selection" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "selection" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      Fl::selection(*arg1,(char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_paste__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *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_Fl_Widget,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "paste" "', argument " "1"" of type '" "Fl_Widget &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "paste" "', argument " "1"" of type '" "Fl_Widget &""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      Fl::paste(*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_paste(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "paste", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_paste__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 2) && (argc <= 3)) {
    PyObject *retobj = _wrap_paste__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'paste'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::paste(Fl_Widget &,int,char const *)\n"
    "    Fl::paste(Fl_Widget &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_x(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "x", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::x(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_y(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "y", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::y(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "w", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::w(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "h", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::h(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_screen_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "screen_count", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::screen_count(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_screen_xywh__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int temp1 ;
  int res1 = SWIG_TMPOBJ ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  
  arg1 = &temp1;
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      Fl::screen_xywh(*arg1,*arg2,*arg3,*arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res1)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_screen_xywh__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int arg5 ;
  int arg6 ;
  int temp1 ;
  int res1 = SWIG_TMPOBJ ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  arg1 = &temp1;
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode5 = SWIG_AsVal_int(swig_obj[0], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "screen_xywh" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[1], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "screen_xywh" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  {
    try {
      Fl::screen_xywh(*arg1,*arg2,*arg3,*arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res1)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_screen_xywh__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int arg5 ;
  int temp1 ;
  int res1 = SWIG_TMPOBJ ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  
  arg1 = &temp1;
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode5 = SWIG_AsVal_int(swig_obj[0], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "screen_xywh" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      Fl::screen_xywh(*arg1,*arg2,*arg3,*arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res1)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_screen_xywh__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int temp1 ;
  int res1 = SWIG_TMPOBJ ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  
  arg1 = &temp1;
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode5 = SWIG_AsVal_int(swig_obj[0], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "screen_xywh" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[1], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "screen_xywh" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[2], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "screen_xywh" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = (int)(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[3], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "screen_xywh" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = (int)(val8);
  {
    try {
      Fl::screen_xywh(*arg1,*arg2,*arg3,*arg4,arg5,arg6,arg7,arg8); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res1)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_screen_xywh(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "screen_xywh", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_screen_xywh__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_screen_xywh__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_screen_xywh__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_screen_xywh__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'screen_xywh'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::screen_xywh(int &,int &,int &,int &)\n"
    "    Fl::screen_xywh(int &,int &,int &,int &,int,int)\n"
    "    Fl::screen_xywh(int &,int &,int &,int &,int)\n"
    "    Fl::screen_xywh(int &,int &,int &,int &,int,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_screen_num__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  (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 '" "screen_num" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "screen_num" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)Fl::screen_num(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_screen_num__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "screen_num" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "screen_num" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "screen_num" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "screen_num" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      result = (int)Fl::screen_num(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_screen_num(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "screen_num", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_screen_num__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_screen_num__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'screen_num'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::screen_num(int,int)\n"
    "    Fl::screen_num(int,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_screen_dpi(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float *arg1 = 0 ;
  float *arg2 = 0 ;
  int arg3 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "screen_dpi", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "screen_dpi" "', argument " "1"" of type '" "float &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "screen_dpi" "', argument " "1"" of type '" "float &""'"); 
  }
  arg1 = (float *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "screen_dpi" "', argument " "2"" of type '" "float &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "screen_dpi" "', argument " "2"" of type '" "float &""'"); 
  }
  arg2 = (float *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "screen_dpi" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      Fl::screen_dpi(*arg1,*arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_screen_work_area__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int arg5 ;
  int arg6 ;
  int temp1 ;
  int res1 = SWIG_TMPOBJ ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  arg1 = &temp1;
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode5 = SWIG_AsVal_int(swig_obj[0], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "screen_work_area" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[1], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "screen_work_area" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  {
    try {
      Fl::screen_work_area(*arg1,*arg2,*arg3,*arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res1)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_screen_work_area__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int arg5 ;
  int temp1 ;
  int res1 = SWIG_TMPOBJ ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  
  arg1 = &temp1;
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode5 = SWIG_AsVal_int(swig_obj[0], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "screen_work_area" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      Fl::screen_work_area(*arg1,*arg2,*arg3,*arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res1)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_screen_work_area__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int temp1 ;
  int res1 = SWIG_TMPOBJ ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  
  arg1 = &temp1;
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      Fl::screen_work_area(*arg1,*arg2,*arg3,*arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res1)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_screen_work_area(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "screen_work_area", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_screen_work_area__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_screen_work_area__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_screen_work_area__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'screen_work_area'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::screen_work_area(int &,int &,int &,int &,int,int)\n"
    "    Fl::screen_work_area(int &,int &,int &,int &,int)\n"
    "    Fl::screen_work_area(int &,int &,int &,int &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_screen_scale__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  float result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "screen_scale" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      result = (float)Fl::screen_scale(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_float((float)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_screen_scale__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  float arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 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 '" "screen_scale" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "screen_scale" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = (float)(val2);
  {
    try {
      Fl::screen_scale(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_screen_scale(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "screen_scale", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_screen_scale__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_screen_scale__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'screen_scale'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::screen_scale(int)\n"
    "    Fl::screen_scale(int,float)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_screen_scaling_supported(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "screen_scaling_supported", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::screen_scaling_supported(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_keyboard_screen_scaling(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 '" "keyboard_screen_scaling" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      Fl::keyboard_screen_scaling(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  uchar arg2 ;
  uchar arg3 ;
  uchar arg4 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  unsigned char val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "set_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "set_color" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "set_color" "', argument " "3"" of type '" "uchar""'");
  } 
  arg3 = (uchar)(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "set_color" "', argument " "4"" of type '" "uchar""'");
  } 
  arg4 = (uchar)(val4);
  {
    try {
      Fl::set_color(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  uchar arg2 ;
  uchar arg3 ;
  uchar arg4 ;
  uchar arg5 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  unsigned char val4 ;
  int ecode4 = 0 ;
  unsigned char val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "set_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "set_color" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "set_color" "', argument " "3"" of type '" "uchar""'");
  } 
  arg3 = (uchar)(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "set_color" "', argument " "4"" of type '" "uchar""'");
  } 
  arg4 = (uchar)(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "set_color" "', argument " "5"" of type '" "uchar""'");
  } 
  arg5 = (uchar)(val5);
  {
    try {
      Fl::set_color(arg1,arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_color__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "set_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "set_color" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = (unsigned int)(val2);
  {
    try {
      Fl::set_color(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "set_color", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_set_color__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_set_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_set_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'set_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::set_color(Fl_Color,uchar,uchar,uchar)\n"
    "    Fl::set_color(Fl_Color,uchar,uchar,uchar,uchar)\n"
    "    Fl::set_color(Fl_Color,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_get_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  uchar *arg2 = 0 ;
  uchar *arg3 = 0 ;
  uchar *arg4 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  uchar temp2 ;
  int res2 = SWIG_TMPOBJ ;
  uchar temp3 ;
  int res3 = SWIG_TMPOBJ ;
  uchar temp4 ;
  int res4 = SWIG_TMPOBJ ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  {
    try {
      Fl::get_color(arg1,*arg2,*arg3,*arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*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_unsigned_char, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*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_unsigned_char, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  uchar *arg2 = 0 ;
  uchar *arg3 = 0 ;
  uchar *arg4 = 0 ;
  uchar *arg5 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  uchar temp2 ;
  int res2 = SWIG_TMPOBJ ;
  uchar temp3 ;
  int res3 = SWIG_TMPOBJ ;
  uchar temp4 ;
  int res4 = SWIG_TMPOBJ ;
  uchar temp5 ;
  int res5 = SWIG_TMPOBJ ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  {
    try {
      Fl::get_color(arg1,*arg2,*arg3,*arg4,*arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*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_unsigned_char, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*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_unsigned_char, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg5)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "get_color", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_get_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_get_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'get_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::get_color(Fl_Color,uchar &,uchar &,uchar &)\n"
    "    Fl::get_color(Fl_Color,uchar &,uchar &,uchar &,uchar &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_free_color(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  int arg2 = (int) 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "free_color", 1, 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 '" "free_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "free_color" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      Fl::free_color(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_font(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Font arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_font" "', argument " "1"" of type '" "Fl_Font""'");
  } 
  arg1 = (Fl_Font)(val1);
  {
    try {
      result = (char *)Fl::get_font(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_font_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Font arg1 ;
  int *arg2 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  arg2 = &temp2;
  (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 '" "get_font_name" "', argument " "1"" of type '" "Fl_Font""'");
  } 
  arg1 = (Fl_Font)(val1);
  {
    try {
      result = (char *)Fl::get_font_name(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_font__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Font arg1 ;
  char *arg2 = (char *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 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 '" "set_font" "', argument " "1"" of type '" "Fl_Font""'");
  } 
  arg1 = (Fl_Font)(val1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "set_font" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl::set_font(arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_font__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Font arg1 ;
  Fl_Font arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 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 '" "set_font" "', argument " "1"" of type '" "Fl_Font""'");
  } 
  arg1 = (Fl_Font)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "set_font" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      Fl::set_font(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_font(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "set_font", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_set_font__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_set_font__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'set_font'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::set_font(Fl_Font,char const *)\n"
    "    Fl::set_font(Fl_Font,Fl_Font)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_set_fonts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Font result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "set_fonts", 0, 1, swig_obj)) SWIG_fail;
  if (swig_obj[0]) {
    res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_fonts" "', argument " "1"" of type '" "char const *""'");
    }
    arg1 = (char *)(buf1);
  }
  {
    try {
      result = (Fl_Font)Fl::set_fonts((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_labeltype(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Labeltype arg1 ;
  Fl_Label_Draw_F *arg2 = (Fl_Label_Draw_F *) 0 ;
  Fl_Label_Measure_F *arg3 = (Fl_Label_Measure_F *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "set_labeltype", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "set_labeltype" "', argument " "1"" of type '" "Fl_Labeltype""'");
  } 
  arg1 = (Fl_Labeltype)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Label_Draw_F, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "set_labeltype" "', argument " "2"" of type '" "Fl_Label_Draw_F *""'"); 
  }
  arg2 = (Fl_Label_Draw_F *)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Fl_Label_Measure_F, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "set_labeltype" "', argument " "3"" of type '" "Fl_Label_Measure_F *""'"); 
  }
  arg3 = (Fl_Label_Measure_F *)(argp3);
  {
    try {
      Fl::set_labeltype(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_boxtype(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Box_Draw_F *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_boxtype" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = (Fl_Boxtype)(val1);
  {
    try {
      result = (Fl_Box_Draw_F *)Fl::get_boxtype(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Box_Draw_F, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_boxtype__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  Fl_Box_Draw_F *arg2 = (Fl_Box_Draw_F *) 0 ;
  uchar arg3 ;
  uchar arg4 ;
  uchar arg5 ;
  uchar arg6 ;
  Fl_Box_Draw_Focus_F *arg7 = (Fl_Box_Draw_Focus_F *) NULL ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  unsigned char val4 ;
  int ecode4 = 0 ;
  unsigned char val5 ;
  int ecode5 = 0 ;
  unsigned char val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "set_boxtype" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = (Fl_Boxtype)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Box_Draw_F, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "set_boxtype" "', argument " "2"" of type '" "Fl_Box_Draw_F *""'"); 
  }
  arg2 = (Fl_Box_Draw_F *)(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "set_boxtype" "', argument " "3"" of type '" "uchar""'");
  } 
  arg3 = (uchar)(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "set_boxtype" "', argument " "4"" of type '" "uchar""'");
  } 
  arg4 = (uchar)(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "set_boxtype" "', argument " "5"" of type '" "uchar""'");
  } 
  arg5 = (uchar)(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "set_boxtype" "', argument " "6"" of type '" "uchar""'");
  } 
  arg6 = (uchar)(val6);
  if (swig_obj[6]) {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_Fl_Box_Draw_Focus_F, 0 |  0 );
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "set_boxtype" "', argument " "7"" of type '" "Fl_Box_Draw_Focus_F *""'"); 
    }
    arg7 = (Fl_Box_Draw_Focus_F *)(argp7);
  }
  {
    try {
      Fl::set_boxtype(arg1,arg2,arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_boxtype__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  Fl_Boxtype arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 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 '" "set_boxtype" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = (Fl_Boxtype)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "set_boxtype" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = (Fl_Boxtype)(val2);
  {
    try {
      Fl::set_boxtype(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_boxtype(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "set_boxtype", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_set_boxtype__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 6) && (argc <= 7)) {
    PyObject *retobj = _wrap_set_boxtype__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'set_boxtype'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::set_boxtype(Fl_Boxtype,Fl_Box_Draw_F *,uchar,uchar,uchar,uchar,Fl_Box_Draw_Focus_F *)\n"
    "    Fl::set_boxtype(Fl_Boxtype,Fl_Boxtype)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_box_dx(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "box_dx" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = (Fl_Boxtype)(val1);
  {
    try {
      result = (int)Fl::box_dx(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_box_dy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "box_dy" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = (Fl_Boxtype)(val1);
  {
    try {
      result = (int)Fl::box_dy(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_box_dw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "box_dw" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = (Fl_Boxtype)(val1);
  {
    try {
      result = (int)Fl::box_dw(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_box_dh(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "box_dh" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = (Fl_Boxtype)(val1);
  {
    try {
      result = (int)Fl::box_dh(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_draw_box_active(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "draw_box_active", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::draw_box_active(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_box_color(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Color result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "box_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  {
    try {
      result = (Fl_Color)Fl::box_color(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_box_color(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "set_box_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  {
    try {
      Fl::set_box_color(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_abort(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Abort_Handler arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Abort_Handler,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_abort" "', argument " "1"" of type '" "Fl_Abort_Handler""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "set_abort" "', argument " "1"" of type '" "Fl_Abort_Handler""'");
    } else {
      Fl_Abort_Handler * temp = (Fl_Abort_Handler *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      Fl::set_abort(SWIG_STD_MOVE(arg1)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_default_atclose(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "default_atclose", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "default_atclose" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(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 '" "default_atclose" "', argument " "2"" of type '" "void *""'"); 
  }
  {
    try {
      Fl::default_atclose(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_atclose(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Atclose_Handler arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Atclose_Handler,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_atclose" "', argument " "1"" of type '" "Fl_Atclose_Handler""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "set_atclose" "', argument " "1"" of type '" "Fl_Atclose_Handler""'");
    } else {
      Fl_Atclose_Handler * temp = (Fl_Atclose_Handler *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      Fl::set_atclose(SWIG_STD_MOVE(arg1)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_use_high_res_VK__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 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 '" "use_high_res_VK" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      Fl::use_high_res_VK(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_use_high_res_VK__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::use_high_res_VK(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_use_high_res_VK(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "use_high_res_VK", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_use_high_res_VK__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_use_high_res_VK__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'use_high_res_VK'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::use_high_res_VK(int)\n"
    "    Fl::use_high_res_VK()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_lock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "lock", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::lock(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_unlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "unlock", 0, 0, 0)) SWIG_fail;
  {
    try {
      Fl::unlock(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_awake__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      Fl::awake(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_awake__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  void *arg1 = (void *) 0 ;
  int res1 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "awake" "', argument " "1"" of type '" "void *""'"); 
  }
  {
    try {
      Fl::awake(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_awake__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Awake_Handler arg1 ;
  void *arg2 = (void *) nullptr ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  int result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Awake_Handler,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "awake" "', argument " "1"" of type '" "Fl_Awake_Handler""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "awake" "', argument " "1"" of type '" "Fl_Awake_Handler""'");
    } else {
      Fl_Awake_Handler * temp = (Fl_Awake_Handler *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "awake" "', argument " "2"" of type '" "void *""'"); 
    }
  }
  {
    try {
      result = (int)Fl::awake(SWIG_STD_MOVE(arg1),arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_awake(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "awake", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_awake__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Fl_Awake_Handler, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    PyObject *retobj = _wrap_awake__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_awake__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'awake'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::awake()\n"
    "    Fl::awake(void *)\n"
    "    Fl::awake(Fl_Awake_Handler,void *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_awake_once(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Awake_Handler arg1 ;
  void *arg2 = (void *) nullptr ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "awake_once", 1, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Awake_Handler,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "awake_once" "', argument " "1"" of type '" "Fl_Awake_Handler""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "awake_once" "', argument " "1"" of type '" "Fl_Awake_Handler""'");
    } else {
      Fl_Awake_Handler * temp = (Fl_Awake_Handler *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "awake_once" "', argument " "2"" of type '" "void *""'"); 
    }
  }
  {
    try {
      result = (int)Fl::awake_once(SWIG_STD_MOVE(arg1),arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_thread_message(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "thread_message", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (void *)Fl::thread_message(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_use_high_res_GL__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 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 '" "use_high_res_GL" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      Fl::use_high_res_GL(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_use_high_res_GL__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::use_high_res_GL(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_use_high_res_GL(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "use_high_res_GL", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_use_high_res_GL__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_use_high_res_GL__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'use_high_res_GL'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::use_high_res_GL(int)\n"
    "    Fl::use_high_res_GL()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_draw_GL_text_with_textures__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 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 '" "draw_GL_text_with_textures" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      Fl::draw_GL_text_with_textures(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_draw_GL_text_with_textures__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)Fl::draw_GL_text_with_textures(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_draw_GL_text_with_textures(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "draw_GL_text_with_textures", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_draw_GL_text_with_textures__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_draw_GL_text_with_textures__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'draw_GL_text_with_textures'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::draw_GL_text_with_textures(int)\n"
    "    Fl::draw_GL_text_with_textures()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_system(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "system" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (int)Fl::system((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_args_to_utf8(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  char ***arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "args_to_utf8", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "args_to_utf8" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_p_char,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "args_to_utf8" "', argument " "2"" of type '" "char **&""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "args_to_utf8" "', argument " "2"" of type '" "char **&""'"); 
  }
  arg2 = (char ***)(argp2);
  {
    try {
      result = (int)Fl::args_to_utf8(arg1,*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pyFLTK_controlIdleCallbacks(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 '" "pyFLTK_controlIdleCallbacks" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      pyFLTK_controlIdleCallbacks(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  char *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 '" "fl_filename_name" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (char *)fl_filename_name((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_ext(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  char *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 '" "fl_filename_ext" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (char *)fl_filename_ext((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_setext__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  int res1 ;
  char temp1[1024+1] ;
  char *t1 = 0 ;
  size_t n1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &t1, &n1, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_setext" "', argument " "1"" of type '" "char *to""'");
  }
  if ( n1 > (size_t) 1024 ) n1 = (size_t) 1024;
  memcpy(temp1, t1, sizeof(char)*n1);
  if (alloc1 == SWIG_NEWOBJ) delete[] t1;
  temp1[n1 - 1] = 0;                                                             
  arg1 = (char *) temp1;
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_filename_setext" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_filename_setext" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      result = (char *)fl_filename_setext(arg1,arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  arg1[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1), 0);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_expand__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  int res1 ;
  char temp1[1024+1] ;
  char *t1 = 0 ;
  size_t n1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &t1, &n1, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_expand" "', argument " "1"" of type '" "char *to""'");
  }
  if ( n1 > (size_t) 1024 ) n1 = (size_t) 1024;
  memcpy(temp1, t1, sizeof(char)*n1);
  if (alloc1 == SWIG_NEWOBJ) delete[] t1;
  temp1[n1 - 1] = 0;                                                             
  arg1 = (char *) temp1;
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_filename_expand" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_filename_expand" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      result = (int)fl_filename_expand(arg1,arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  arg1[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1), 0);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_absolute__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  int res1 ;
  char temp1[1024+1] ;
  char *t1 = 0 ;
  size_t n1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &t1, &n1, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_absolute" "', argument " "1"" of type '" "char *to""'");
  }
  if ( n1 > (size_t) 1024 ) n1 = (size_t) 1024;
  memcpy(temp1, t1, sizeof(char)*n1);
  if (alloc1 == SWIG_NEWOBJ) delete[] t1;
  temp1[n1 - 1] = 0;                                                             
  arg1 = (char *) temp1;
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_filename_absolute" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_filename_absolute" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      result = (int)fl_filename_absolute(arg1,arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  arg1[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1), 0);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_relative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  int res1 ;
  char temp1[1024+1] ;
  char *t1 = 0 ;
  size_t n1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &t1, &n1, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_relative" "', argument " "1"" of type '" "char *to""'");
  }
  if ( n1 > (size_t) 1024 ) n1 = (size_t) 1024;
  memcpy(temp1, t1, sizeof(char)*n1);
  if (alloc1 == SWIG_NEWOBJ) delete[] t1;
  temp1[n1 - 1] = 0;                                                             
  arg1 = (char *) temp1;
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_filename_relative" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_filename_relative" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      result = (int)fl_filename_relative(arg1,arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  arg1[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1), 0);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_match(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_filename_match", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_match" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_filename_match" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)fl_filename_match((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_isdir(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_isdir" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (int)fl_filename_isdir((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_absolute__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int res1 ;
  char temp1[1024+1] ;
  char *t1 = 0 ;
  size_t n1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &t1, &n1, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_absolute" "', argument " "1"" of type '" "char *to""'");
  }
  if ( n1 > (size_t) 1024 ) n1 = (size_t) 1024;
  memcpy(temp1, t1, sizeof(char)*n1);
  if (alloc1 == SWIG_NEWOBJ) delete[] t1;
  temp1[n1 - 1] = 0;                                                             
  arg1 = (char *) temp1;
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_filename_absolute" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_filename_absolute" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "fl_filename_absolute" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = (char *)(buf4);
  {
    try {
      result = (int)fl_filename_absolute(arg1,arg2,(char const *)arg3,(char const *)arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  arg1[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1), 0);
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_relative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int res1 ;
  char temp1[1024+1] ;
  char *t1 = 0 ;
  size_t n1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &t1, &n1, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_relative" "', argument " "1"" of type '" "char *to""'");
  }
  if ( n1 > (size_t) 1024 ) n1 = (size_t) 1024;
  memcpy(temp1, t1, sizeof(char)*n1);
  if (alloc1 == SWIG_NEWOBJ) delete[] t1;
  temp1[n1 - 1] = 0;                                                             
  arg1 = (char *) temp1;
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_filename_relative" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_filename_relative" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "fl_filename_relative" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = (char *)(buf4);
  {
    try {
      result = (int)fl_filename_relative(arg1,arg2,(char const *)arg3,(char const *)arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  arg1[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1), 0);
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_name_str(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_name_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_filename_name_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = fl_filename_name_str((std::string const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_std_string((std::string)(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_path_str(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_path_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_filename_path_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = fl_filename_path_str((std::string const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_std_string((std::string)(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_ext_str(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_ext_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_filename_ext_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = fl_filename_ext_str((std::string const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_std_string((std::string)(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_setext_str(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_filename_setext_str", 2, 2, swig_obj)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_setext_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_filename_setext_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_filename_setext_str" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_filename_setext_str" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = fl_filename_setext_str((std::string const &)*arg1,(std::string const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_std_string((std::string)(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_expand_str(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_expand_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_filename_expand_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = fl_filename_expand_str((std::string const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_std_string((std::string)(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_absolute_str__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::string result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_absolute_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_filename_absolute_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = fl_filename_absolute_str((std::string const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_std_string((std::string)(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_absolute_str__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  std::string result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_absolute_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_filename_absolute_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_filename_absolute_str" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_filename_absolute_str" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = fl_filename_absolute_str((std::string const &)*arg1,(std::string const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_std_string((std::string)(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_absolute_str(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_filename_absolute_str", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_fl_filename_absolute_str__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_fl_filename_absolute_str__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_filename_absolute_str'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_filename_absolute_str(std::string const &)\n"
    "    fl_filename_absolute_str(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_filename_relative_str__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::string result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_relative_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_filename_relative_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = fl_filename_relative_str((std::string const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_std_string((std::string)(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_relative_str__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  std::string result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_relative_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_filename_relative_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_filename_relative_str" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_filename_relative_str" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = fl_filename_relative_str((std::string const &)*arg1,(std::string const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_std_string((std::string)(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_relative_str(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_filename_relative_str", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_fl_filename_relative_str__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_fl_filename_relative_str__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_filename_relative_str'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_filename_relative_str(std::string const &)\n"
    "    fl_filename_relative_str(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_getcwd_str(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_getcwd_str", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = fl_getcwd_str(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_std_string((std::string)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_setext__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char temp1[1024+1] ;
  char *t1 = 0 ;
  size_t n1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &t1, &n1, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_setext" "', argument " "1"" of type '" "char *to""'");
  }
  if ( n1 > (size_t) 1024 ) n1 = (size_t) 1024;
  memcpy(temp1, t1, sizeof(char)*n1);
  if (alloc1 == SWIG_NEWOBJ) delete[] t1;
  temp1[n1 - 1] = 0;                                                             
  arg1 = (char *) temp1;
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_filename_setext" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (char *)fl_filename_setext(arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  arg1[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1), 0);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_setext(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_filename_setext", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_fl_filename_setext__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_fl_filename_setext__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_filename_setext'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_filename_setext(char *,int,char const *)\n"
    "    fl_filename_setext(char *,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_filename_expand__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char temp1[1024+1] ;
  char *t1 = 0 ;
  size_t n1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &t1, &n1, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_expand" "', argument " "1"" of type '" "char *to""'");
  }
  if ( n1 > (size_t) 1024 ) n1 = (size_t) 1024;
  memcpy(temp1, t1, sizeof(char)*n1);
  if (alloc1 == SWIG_NEWOBJ) delete[] t1;
  temp1[n1 - 1] = 0;                                                             
  arg1 = (char *) temp1;
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_filename_expand" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)fl_filename_expand(arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  arg1[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1), 0);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_expand(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_filename_expand", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_fl_filename_expand__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_fl_filename_expand__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_filename_expand'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_filename_expand(char *,int,char const *)\n"
    "    fl_filename_expand(char *,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_filename_absolute__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char temp1[1024+1] ;
  char *t1 = 0 ;
  size_t n1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &t1, &n1, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_absolute" "', argument " "1"" of type '" "char *to""'");
  }
  if ( n1 > (size_t) 1024 ) n1 = (size_t) 1024;
  memcpy(temp1, t1, sizeof(char)*n1);
  if (alloc1 == SWIG_NEWOBJ) delete[] t1;
  temp1[n1 - 1] = 0;                                                             
  arg1 = (char *) temp1;
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_filename_absolute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)fl_filename_absolute(arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  arg1[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1), 0);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_absolute(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_filename_absolute", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_fl_filename_absolute__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_fl_filename_absolute__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_fl_filename_absolute__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_filename_absolute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_filename_absolute(char *,int,char const *)\n"
    "    fl_filename_absolute(char *,int,char const *,char const *)\n"
    "    fl_filename_absolute(char *,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_filename_relative__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char temp1[1024+1] ;
  char *t1 = 0 ;
  size_t n1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &t1, &n1, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_relative" "', argument " "1"" of type '" "char *to""'");
  }
  if ( n1 > (size_t) 1024 ) n1 = (size_t) 1024;
  memcpy(temp1, t1, sizeof(char)*n1);
  if (alloc1 == SWIG_NEWOBJ) delete[] t1;
  temp1[n1 - 1] = 0;                                                             
  arg1 = (char *) temp1;
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_filename_relative" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)fl_filename_relative(arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  arg1[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1), 0);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_relative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_filename_relative", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_fl_filename_relative__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_fl_filename_relative__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_fl_filename_relative__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_filename_relative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_filename_relative(char *,int,char const *)\n"
    "    fl_filename_relative(char *,int,char const *,char const *)\n"
    "    fl_filename_relative(char *,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_filename_free_list(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  dirent ***arg1 = (dirent ***) 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, "fl_filename_free_list", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_p_p_dirent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_filename_free_list" "', argument " "1"" of type '" "dirent ***""'"); 
  }
  arg1 = (dirent ***)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_filename_free_list" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      fl_filename_free_list(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_open_uri(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) (char *) 0 ;
  int arg3 = (int) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_open_uri", 1, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_open_uri" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  if (swig_obj[1]) {
    res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_open_uri" "', argument " "2"" of type '" "char *""'");
    }
    arg2 = (char *)(buf2);
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_open_uri" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)fl_open_uri((char const *)arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_decode_uri(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_decode_uri" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      fl_decode_uri(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Valuator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Valuator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Valuator", 6, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Valuator" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Valuator" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Valuator" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Valuator" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Valuator" "', argument " "6"" of type '" "char const *""'");
  }
  arg6 = (char *)(buf6);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Valuator *)new SwigDirector_Fl_Valuator(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
        SWIG_fail;
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Valuator, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Valuator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Valuator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Valuator" "', argument " "1"" of type '" "Fl_Valuator *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_bounds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Valuator_bounds", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Valuator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Valuator_bounds" "', argument " "1"" of type '" "Fl_Valuator *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_bounds" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Valuator_bounds" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  {
    try {
      (arg1)->bounds(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_minimum__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 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_Fl_Valuator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Valuator_minimum" "', argument " "1"" of type '" "Fl_Valuator const *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  {
    try {
      result = (double)((Fl_Valuator const *)arg1)->minimum(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_minimum__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 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_Fl_Valuator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Valuator_minimum" "', argument " "1"" of type '" "Fl_Valuator *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_minimum" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      (arg1)->minimum(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_minimum(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Valuator_minimum", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Valuator_minimum__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Valuator_minimum__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Valuator_minimum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Valuator::minimum() const\n"
    "    Fl_Valuator::minimum(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_maximum__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 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_Fl_Valuator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Valuator_maximum" "', argument " "1"" of type '" "Fl_Valuator const *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  {
    try {
      result = (double)((Fl_Valuator const *)arg1)->maximum(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_maximum__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 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_Fl_Valuator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Valuator_maximum" "', argument " "1"" of type '" "Fl_Valuator *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_maximum" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      (arg1)->maximum(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_maximum(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Valuator_maximum", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Valuator_maximum__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Valuator_maximum__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Valuator_maximum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Valuator::maximum() const\n"
    "    Fl_Valuator::maximum(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_range(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Valuator_range", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Valuator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Valuator_range" "', argument " "1"" of type '" "Fl_Valuator *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_range" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Valuator_range" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  {
    try {
      (arg1)->range(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_step__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 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_Fl_Valuator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Valuator_step" "', argument " "1"" of type '" "Fl_Valuator *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_step" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->step(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_step__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 0 ;
  double arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double 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_Fl_Valuator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Valuator_step" "', argument " "1"" of type '" "Fl_Valuator *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_step" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Valuator_step" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->step(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_step__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 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_Fl_Valuator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Valuator_step" "', argument " "1"" of type '" "Fl_Valuator *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_step" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      (arg1)->step(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_step__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 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_Fl_Valuator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Valuator_step" "', argument " "1"" of type '" "Fl_Valuator const *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  {
    try {
      result = (double)((Fl_Valuator const *)arg1)->step(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_step(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Valuator_step", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Valuator_step__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_Fl_Valuator_step__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Valuator_step__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Valuator_step__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Valuator_step'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Valuator::step(int)\n"
    "    Fl_Valuator::step(double,int)\n"
    "    Fl_Valuator::step(double)\n"
    "    Fl_Valuator::step() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_precision(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 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, "Fl_Valuator_precision", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Valuator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Valuator_precision" "', argument " "1"" of type '" "Fl_Valuator *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_precision" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->precision(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 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_Fl_Valuator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Valuator_value" "', argument " "1"" of type '" "Fl_Valuator const *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  {
    try {
      result = (double)((Fl_Valuator const *)arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Valuator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Valuator_value" "', argument " "1"" of type '" "Fl_Valuator *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_value" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      result = (int)(arg1)->value(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Valuator_value", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Valuator_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Valuator_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Valuator_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Valuator::value() const\n"
    "    Fl_Valuator::value(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_format(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *t2 = 0 ;
  size_t n2 = 0 ;
  int alloc2 = 0 ;
  size_t expansion2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Valuator_format", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Valuator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Valuator_format" "', argument " "1"" of type '" "Fl_Valuator *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &t2, &n2, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Valuator_format" "', argument " "2"" of type '" "char* format_string""'");
  }
  arg2 = (new char[n2+expansion2]());          
  memcpy(arg2,t2,sizeof(char)*n2);
  if (alloc2 == SWIG_NEWOBJ) delete[] t2;
  arg2[n2-1] = 0;
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Valuator::format(arg2);
        } else {
          result = (int)(arg1)->format(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg2), 0);
  delete[] arg2;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_round(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Valuator_round", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Valuator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Valuator_round" "', argument " "1"" of type '" "Fl_Valuator *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_round" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      result = (double)(arg1)->round(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_clamp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Valuator_clamp", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Valuator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Valuator_clamp" "', argument " "1"" of type '" "Fl_Valuator *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_clamp" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      result = (double)(arg1)->clamp(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_increment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 0 ;
  double arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Valuator_increment", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Valuator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Valuator_increment" "', argument " "1"" of type '" "Fl_Valuator *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_increment" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Valuator_increment" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (double)(arg1)->increment(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 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, "Fl_Valuator_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Valuator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Valuator_init_type" "', argument " "1"" of type '" "Fl_Valuator *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Valuator_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Valuator_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Valuator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Valuator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Valuator" "', argument " "1"" of type '" "Fl_Valuator *""'"); 
  }
  arg1 = (Fl_Valuator *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Adjuster_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Adjuster *arg1 = (Fl_Adjuster *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Adjuster *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Adjuster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Adjuster_draw" "', argument " "1"" of type '" "Fl_Adjuster *""'"); 
  }
  arg1 = (Fl_Adjuster *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Adjuster *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Adjuster_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Adjuster *arg1 = (Fl_Adjuster *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Adjuster *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Adjuster_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Adjuster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Adjuster_handle" "', argument " "1"" of type '" "Fl_Adjuster *""'"); 
  }
  arg1 = (Fl_Adjuster *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Adjuster_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("handle"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member handle");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Adjuster *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)(darg)->handleSwigPublic(arg2);
        } else {
          result = (int)(darg)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Adjuster(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Adjuster *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Adjuster", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Adjuster" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Adjuster" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Adjuster" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Adjuster" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Adjuster" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Adjuster *)new SwigDirector_Fl_Adjuster(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Adjuster *)new Fl_Adjuster(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Adjuster, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Adjuster_soft__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Adjuster *arg1 = (Fl_Adjuster *) 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_Fl_Adjuster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Adjuster_soft" "', argument " "1"" of type '" "Fl_Adjuster *""'"); 
  }
  arg1 = (Fl_Adjuster *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Adjuster_soft" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->soft(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Adjuster_soft__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Adjuster *arg1 = (Fl_Adjuster *) 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_Fl_Adjuster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Adjuster_soft" "', argument " "1"" of type '" "Fl_Adjuster const *""'"); 
  }
  arg1 = (Fl_Adjuster *)(argp1);
  {
    try {
      result = (int)((Fl_Adjuster const *)arg1)->soft(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Adjuster_soft(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Adjuster_soft", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Adjuster_soft__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Adjuster_soft__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Adjuster_soft'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Adjuster::soft(int)\n"
    "    Fl_Adjuster::soft() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Adjuster_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Adjuster *arg1 = (Fl_Adjuster *) 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, "Fl_Adjuster_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Adjuster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Adjuster_init_type" "', argument " "1"" of type '" "Fl_Adjuster *""'"); 
  }
  arg1 = (Fl_Adjuster *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Adjuster_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Adjuster_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Adjuster(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Adjuster *arg1 = (Fl_Adjuster *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Adjuster, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Adjuster" "', argument " "1"" of type '" "Fl_Adjuster *""'"); 
  }
  arg1 = (Fl_Adjuster *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Adjuster(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Adjuster *arg1 = (Fl_Adjuster *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Adjuster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Adjuster" "', argument " "1"" of type '" "Fl_Adjuster *""'"); 
  }
  arg1 = (Fl_Adjuster *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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


#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif

SWIGINTERN PyObject *_wrap_fl_beep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 = (int) FL_BEEP_DEFAULT ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_beep", 0, 1, swig_obj)) SWIG_fail;
  if (swig_obj[0]) {
    ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_beep" "', argument " "1"" of type '" "int""'");
    } 
    arg1 = (int)(val1);
  }
  {
    try {
      fl_beep(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_message__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, "fl_message", 1, 1, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_message" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      fl_message((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_message(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_fl_message__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_fl_alert__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, "fl_alert", 1, 1, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_alert" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      fl_alert((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_alert(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_fl_alert__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_fl_ask__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 ;
  int result;
  
  (void)self;
  if (!PyArg_UnpackTuple(args, "fl_ask", 1, 1, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_ask" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (int)fl_ask((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_ask(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_fl_ask__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_fl_choice__varargs__(PyObject *self, PyObject *args, PyObject *varargs) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  void *arg5 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  (void)self;
  if (!PyArg_UnpackTuple(args, "fl_choice", 4, 4, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_choice" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_choice" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_choice" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "fl_choice" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = (char *)(buf4);
  {
    try {
      result = (int)fl_choice((char const *)arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_choice(PyObject *self, PyObject *args) {
  PyObject *resultobj;
  PyObject *varargs;
  PyObject *newargs;
  
  newargs = PyTuple_GetSlice(args, 0, 4);
  varargs = PyTuple_GetSlice(args, 4, PyTuple_Size(args));
  resultobj = _wrap_fl_choice__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_fl_choice_n__varargs__(PyObject *self, PyObject *args, PyObject *varargs) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  void *arg5 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  (void)self;
  if (!PyArg_UnpackTuple(args, "fl_choice_n", 4, 4, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_choice_n" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_choice_n" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_choice_n" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "fl_choice_n" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = (char *)(buf4);
  {
    try {
      result = (int)fl_choice_n((char const *)arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_choice_n(PyObject *self, PyObject *args) {
  PyObject *resultobj;
  PyObject *varargs;
  PyObject *newargs;
  
  newargs = PyTuple_GetSlice(args, 0, 4);
  varargs = PyTuple_GetSlice(args, 4, PyTuple_Size(args));
  resultobj = _wrap_fl_choice_n__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_fl_message_icon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_message_icon", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Widget *)fl_message_icon(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Widget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_message_font(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Font arg1 ;
  Fl_Fontsize arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_message_font", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_message_font" "', argument " "1"" of type '" "Fl_Font""'");
  } 
  arg1 = (Fl_Font)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_message_font" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      fl_message_font(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_message_hotspot__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 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 '" "fl_message_hotspot" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      fl_message_hotspot(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_message_hotspot__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)fl_message_hotspot(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_message_hotspot(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_message_hotspot", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_fl_message_hotspot__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_fl_message_hotspot__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_message_hotspot'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_message_hotspot(int)\n"
    "    fl_message_hotspot()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_message_position__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 = (int) (int)0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_message_position" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_message_position" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_message_position" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      fl_message_position(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_message_position__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_message_position" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      fl_message_position(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_message_position__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int *arg1 = (int *) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 2)) SWIG_fail;
  if (swig_obj[0]) {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_int, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_message_position" "', argument " "1"" of type '" "int *""'"); 
    }
    arg1 = (int *)(argp1);
  }
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_message_position" "', argument " "2"" of type '" "int *""'"); 
    }
    arg2 = (int *)(argp2);
  }
  {
    try {
      result = (int)fl_message_position(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_message_position__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *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_Fl_Widget,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_message_position" "', argument " "1"" of type '" "Fl_Widget &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_message_position" "', argument " "1"" of type '" "Fl_Widget &""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      fl_message_position(*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_message_position(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_message_position", 0, 3, argv))) SWIG_fail;
  --argc;
  if ((argc >= 0) && (argc <= 2)) {
    int _v = 0;
    if (argc > 0) {
      {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
      }
      if (!_v) goto check_1;
      if (argc > 1) {
        {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
          _v = SWIG_CheckState(res);
        }
        if (!_v) goto check_1;
      }
    }
    return _wrap_fl_message_position__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Fl_Widget, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_fl_message_position__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_fl_message_position__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 2) && (argc <= 3)) {
    PyObject *retobj = _wrap_fl_message_position__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_message_position'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_message_position(int const,int const,int const)\n"
    "    fl_message_position(Fl_Widget *)\n"
    "    fl_message_position(int *,int *)\n"
    "    fl_message_position(Fl_Widget &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_message_title(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_message_title" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      fl_message_title((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_message_title_default(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_message_title_default" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      fl_message_title_default((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_message_icon_label(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_message_icon_label" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      fl_message_icon_label((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}



#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif

SWIGINTERN PyObject *_wrap_fl_input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_input", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_input" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  if (swig_obj[1]) {
    res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_input" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = (char *)(buf2);
  }
  {
    try {
      result = (char *)fl_vararg_input((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_password(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_password", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_password" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  if (swig_obj[1]) {
    res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_password" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = (char *)(buf2);
  }
  {
    try {
      result = (char *)fl_vararg_password((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_no_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_no_get", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (char *)fl_no_get(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_yes_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_yes_get", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (char *)fl_yes_get(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_ok_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_ok_get", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (char *)fl_ok_get(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_cancel_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_cancel_get", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (char *)fl_cancel_get(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_close_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_close_get", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (char *)fl_close_get(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_no_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_no_set" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      fl_no_set((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_yes_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_yes_set" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      fl_yes_set((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_ok_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_ok_set" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      fl_ok_set((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_cancel_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_cancel_set" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      fl_cancel_set((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_close_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_close_set" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      fl_close_set((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_mt_message(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_mt_message" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      fl_mt_message((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_mt_alert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_mt_alert" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      fl_mt_alert((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_mt_choice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 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 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_mt_choice", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_mt_choice" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_mt_choice" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_mt_choice" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "fl_mt_choice" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = (char *)(buf4);
  {
    try {
      result = (int)fl_mt_choice((char const *)arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_mt_input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_mt_input", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_mt_input" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  if (swig_obj[1]) {
    res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_mt_input" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = (char *)(buf2);
  }
  {
    try {
      result = (char *)fl_mt_input((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_mt_password(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_mt_password", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_mt_password" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  if (swig_obj[1]) {
    res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_mt_password" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = (char *)(buf2);
  }
  {
    try {
      result = (char *)fl_mt_password((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Bitmap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  uchar *arg2 = (uchar *) 0 ;
  int arg3 ;
  int arg4 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Fl_Bitmap *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = swig_obj[0];
  {
    /* Check if the input support the buffer protocol */
    Py_buffer view;
    const void * buffer;
    int failure = PyObject_GetBuffer(swig_obj[1], &view, PyBUF_CONTIG_RO);
    if (!failure) {
      // work with array object
      buffer = view.buf;
      PyBuffer_Release(&view);
      arg2 = (uchar *) buffer;
    } else {
      // work with list object
      // clear the error from PyObject_GetBuffer
      PyErr_Clear();
      buffer=0;
      /* Check if is a list */
      if (PyList_Check(swig_obj[1])) {
        Py_ssize_t size = PyList_Size(swig_obj[1]);
        int i = 0;
        arg2 = (uchar *) malloc((size+1)*sizeof(char));
        for (i = 0; i < size; i++) {
          PyObject *o = 	PyList_GetItem(swig_obj[1],i);
          if (PyInt_Check(o))
          arg2[i] = (char)PyInt_AsLong(o);
          else {
            PyErr_SetString(PyExc_TypeError,"list must contain ints");
            free(arg2);
            return NULL;
          }
        }
        arg2[i] = 0;
      } else {
        PyErr_SetString(PyExc_TypeError,"not a list or does not support single-segment readable buffer interface");
        return NULL;
      }
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Bitmap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Bitmap" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Bitmap *)new SwigDirector_Fl_Bitmap(arg1,(uchar const *)arg2,arg3,arg4); 
      } else {
        result = (Fl_Bitmap *)new Fl_Bitmap((uchar const *)arg2,arg3,arg4); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Bitmap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Bitmap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  uchar *arg2 = (uchar *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Fl_Bitmap *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  arg1 = swig_obj[0];
  {
    /* Check if the input support the buffer protocol */
    Py_buffer view;
    const void * buffer;
    int failure = PyObject_GetBuffer(swig_obj[1], &view, PyBUF_CONTIG_RO);
    if (!failure) {
      // work with array object
      buffer = view.buf;
      PyBuffer_Release(&view);
      arg2 = (uchar *) buffer;
    } else {
      // work with list object
      // clear the error from PyObject_GetBuffer
      PyErr_Clear();
      buffer=0;
      /* Check if is a list */
      if (PyList_Check(swig_obj[1])) {
        Py_ssize_t size = PyList_Size(swig_obj[1]);
        int i = 0;
        arg2 = (uchar *) malloc((size+1)*sizeof(char));
        for (i = 0; i < size; i++) {
          PyObject *o = 	PyList_GetItem(swig_obj[1],i);
          if (PyInt_Check(o))
          arg2[i] = (char)PyInt_AsLong(o);
          else {
            PyErr_SetString(PyExc_TypeError,"list must contain ints");
            free(arg2);
            return NULL;
          }
        }
        arg2[i] = 0;
      } else {
        PyErr_SetString(PyExc_TypeError,"not a list or does not support single-segment readable buffer interface");
        return NULL;
      }
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Bitmap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Bitmap" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Bitmap" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Bitmap *)new SwigDirector_Fl_Bitmap(arg1,(uchar const *)arg2,arg3,arg4,arg5); 
      } else {
        result = (Fl_Bitmap *)new Fl_Bitmap((uchar const *)arg2,arg3,arg4,arg5); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Bitmap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Bitmap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Fl_Bitmap *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_Bitmap" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Bitmap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Bitmap" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Bitmap" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Bitmap *)new SwigDirector_Fl_Bitmap(arg1,(char const *)arg2,arg3,arg4,arg5); 
      } else {
        result = (Fl_Bitmap *)new Fl_Bitmap((char const *)arg2,arg3,arg4,arg5); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Bitmap, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Bitmap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_Bitmap", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    PyObject *retobj = _wrap_new_Fl_Bitmap__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    PyObject *retobj = _wrap_new_Fl_Bitmap__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_2:
  
  if (argc == 5) {
    PyObject *retobj = _wrap_new_Fl_Bitmap__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_Bitmap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Bitmap::Fl_Bitmap(uchar const *,int,int)\n"
    "    Fl_Bitmap::Fl_Bitmap(uchar const *,int,int,int)\n"
    "    Fl_Bitmap::Fl_Bitmap(PyObject *,char const *,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Bitmap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Bitmap *arg1 = (Fl_Bitmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Bitmap, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Bitmap" "', argument " "1"" of type '" "Fl_Bitmap *""'"); 
  }
  arg1 = (Fl_Bitmap *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Bitmap_copy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Bitmap *arg1 = (Fl_Bitmap *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Bitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Bitmap_copy" "', argument " "1"" of type '" "Fl_Bitmap const *""'"); 
  }
  arg1 = (Fl_Bitmap *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Bitmap_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Bitmap_copy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Image *)((Fl_Bitmap const *)arg1)->Fl_Bitmap::copy(arg2,arg3);
        } else {
          result = (Fl_Image *)((Fl_Bitmap const *)arg1)->copy(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, SWIG_POINTER_OWN |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Bitmap_copy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Bitmap *arg1 = (Fl_Bitmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Bitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Bitmap_copy" "', argument " "1"" of type '" "Fl_Bitmap const *""'"); 
  }
  arg1 = (Fl_Bitmap *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Bitmap const *)arg1)->copy(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Bitmap_copy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Bitmap_copy", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Bitmap_copy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Bitmap_copy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Bitmap_copy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Bitmap::copy(int,int) const\n"
    "    Fl_Bitmap::copy() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Bitmap_draw__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Bitmap *arg1 = (Fl_Bitmap *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 = (int) 0 ;
  int arg7 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Bitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Bitmap_draw" "', argument " "1"" of type '" "Fl_Bitmap *""'"); 
  }
  arg1 = (Fl_Bitmap *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Bitmap_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Bitmap_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Bitmap_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Bitmap_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Bitmap_draw" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Bitmap_draw" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Bitmap::draw(arg2,arg3,arg4,arg5,arg6,arg7);
        } else {
          (arg1)->draw(arg2,arg3,arg4,arg5,arg6,arg7);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Bitmap_draw__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Bitmap *arg1 = (Fl_Bitmap *) 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_Fl_Bitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Bitmap_draw" "', argument " "1"" of type '" "Fl_Bitmap *""'"); 
  }
  arg1 = (Fl_Bitmap *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Bitmap_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Bitmap_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->draw(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Bitmap_draw(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Bitmap_draw", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Bitmap_draw__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 5) && (argc <= 7)) {
    PyObject *retobj = _wrap_Fl_Bitmap_draw__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Bitmap_draw'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Bitmap::draw(int,int,int,int,int,int)\n"
    "    Fl_Bitmap::draw(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Bitmap_label__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Bitmap *arg1 = (Fl_Bitmap *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Bitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Bitmap_label" "', argument " "1"" of type '" "Fl_Bitmap *""'"); 
  }
  arg1 = (Fl_Bitmap *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Bitmap_label" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Bitmap::label(arg2);
        } else {
          (arg1)->label(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Bitmap_label__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Bitmap *arg1 = (Fl_Bitmap *) 0 ;
  Fl_Menu_Item *arg2 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Bitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Bitmap_label" "', argument " "1"" of type '" "Fl_Bitmap *""'"); 
  }
  arg1 = (Fl_Bitmap *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Bitmap_label" "', argument " "2"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg2 = (Fl_Menu_Item *)(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Bitmap::label(arg2);
        } else {
          (arg1)->label(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Bitmap_label(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Bitmap_label", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Widget, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Bitmap_label__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Bitmap_label__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Bitmap_label'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Bitmap::label(Fl_Widget *)\n"
    "    Fl_Bitmap::label(Fl_Menu_Item *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Bitmap_uncache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Bitmap *arg1 = (Fl_Bitmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Bitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Bitmap_uncache" "', argument " "1"" of type '" "Fl_Bitmap *""'"); 
  }
  arg1 = (Fl_Bitmap *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Bitmap::uncache();
        } else {
          (arg1)->uncache();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Bitmap_cache_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Bitmap *arg1 = (Fl_Bitmap *) 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_Fl_Bitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Bitmap_cache_w" "', argument " "1"" of type '" "Fl_Bitmap *""'"); 
  }
  arg1 = (Fl_Bitmap *)(argp1);
  {
    try {
      result = (int)(arg1)->cache_w(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Bitmap_cache_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Bitmap *arg1 = (Fl_Bitmap *) 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_Fl_Bitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Bitmap_cache_h" "', argument " "1"" of type '" "Fl_Bitmap *""'"); 
  }
  arg1 = (Fl_Bitmap *)(argp1);
  {
    try {
      result = (int)(arg1)->cache_h(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Bitmap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Bitmap *arg1 = (Fl_Bitmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Bitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Bitmap" "', argument " "1"" of type '" "Fl_Bitmap *""'"); 
  }
  arg1 = (Fl_Bitmap *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_BMP_Image__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  Fl_BMP_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_BMP_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_BMP_Image *)new SwigDirector_Fl_BMP_Image(arg1,(char const *)arg2); 
      } else {
        result = (Fl_BMP_Image *)new Fl_BMP_Image((char const *)arg2); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_BMP_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_BMP_Image__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  unsigned char *arg3 = (unsigned char *) 0 ;
  long arg4 = (long) (long)-1 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  long val4 ;
  int ecode4 = 0 ;
  Fl_BMP_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_BMP_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fl_BMP_Image" "', argument " "3"" of type '" "unsigned char const *""'"); 
  }
  arg3 = (unsigned char *)(argp3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_long(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_BMP_Image" "', argument " "4"" of type '" "long""'");
    } 
    arg4 = (long)(val4);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_BMP_Image *)new SwigDirector_Fl_BMP_Image(arg1,(char const *)arg2,(unsigned char const *)arg3,arg4); 
      } else {
        result = (Fl_BMP_Image *)new Fl_BMP_Image((char const *)arg2,(unsigned char const *)arg3,arg4); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_BMP_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_BMP_Image(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_BMP_Image", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Fl_BMP_Image__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 3) && (argc <= 4)) {
    PyObject *retobj = _wrap_new_Fl_BMP_Image__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_BMP_Image'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_BMP_Image::Fl_BMP_Image(char const *)\n"
    "    Fl_BMP_Image::Fl_BMP_Image(PyObject *,char const *,unsigned char const *,long const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_BMP_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_BMP_Image *arg1 = (Fl_BMP_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_BMP_Image, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_BMP_Image" "', argument " "1"" of type '" "Fl_BMP_Image *""'"); 
  }
  arg1 = (Fl_BMP_Image *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_BMP_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_BMP_Image *arg1 = (Fl_BMP_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_BMP_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_BMP_Image" "', argument " "1"" of type '" "Fl_BMP_Image *""'"); 
  }
  arg1 = (Fl_BMP_Image *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Box_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Box *arg1 = (Fl_Box *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Box *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Box_draw" "', argument " "1"" of type '" "Fl_Box *""'"); 
  }
  arg1 = (Fl_Box *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Box *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Box__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  Fl_Box *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Box" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Box" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Box" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Box" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Box" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Box *)new SwigDirector_Fl_Box(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Box *)new Fl_Box(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Box, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Box__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  Fl_Boxtype arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  char *arg7 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int res7 ;
  char *buf7 = 0 ;
  int alloc7 = 0 ;
  Fl_Box *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Box" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = (Fl_Boxtype)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Box" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Box" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Box" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fl_Box" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  res7 = SWIG_AsCharPtrAndSize(swig_obj[6], &buf7, NULL, &alloc7);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Fl_Box" "', argument " "7"" of type '" "char const *""'");
  }
  arg7 = (char *)(buf7);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Box *)new SwigDirector_Fl_Box(arg1,arg2,arg3,arg4,arg5,arg6,(char const *)arg7); 
      } else {
        result = (Fl_Box *)new Fl_Box(arg2,arg3,arg4,arg5,arg6,(char const *)arg7); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Box, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Box(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_Box", 0, 7, argv))) SWIG_fail;
  --argc;
  if ((argc >= 5) && (argc <= 6)) {
    PyObject *retobj = _wrap_new_Fl_Box__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_new_Fl_Box__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_Box'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Box::Fl_Box(int,int,int,int,char const *)\n"
    "    Fl_Box::Fl_Box(PyObject *,Fl_Boxtype,int,int,int,int,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Box_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Box *arg1 = (Fl_Box *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Box_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Box_handle" "', argument " "1"" of type '" "Fl_Box *""'"); 
  }
  arg1 = (Fl_Box *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Box_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Box::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Box_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Box *arg1 = (Fl_Box *) 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, "Fl_Box_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Box_init_type" "', argument " "1"" of type '" "Fl_Box *""'"); 
  }
  arg1 = (Fl_Box *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Box_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Box_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Box(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Box *arg1 = (Fl_Box *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Box, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Box" "', argument " "1"" of type '" "Fl_Box *""'"); 
  }
  arg1 = (Fl_Box *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Box(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Box *arg1 = (Fl_Box *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Box" "', argument " "1"" of type '" "Fl_Box *""'"); 
  }
  arg1 = (Fl_Box *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Button_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Button *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Button_draw" "', argument " "1"" of type '" "Fl_Button *""'"); 
  }
  arg1 = (Fl_Button *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Button *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Button_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Button_handle" "', argument " "1"" of type '" "Fl_Button *""'"); 
  }
  arg1 = (Fl_Button *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Button_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Button::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Button *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Button", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Button" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Button *)new SwigDirector_Fl_Button(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Button *)new Fl_Button(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Button, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 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_Fl_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Button_value" "', argument " "1"" of type '" "Fl_Button *""'"); 
  }
  arg1 = (Fl_Button *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Button_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)(arg1)->value(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Button_value" "', argument " "1"" of type '" "Fl_Button const *""'"); 
  }
  arg1 = (Fl_Button *)(argp1);
  {
    try {
      result = (char)((Fl_Button const *)arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Button_value", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Button_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Button_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Button_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Button::value(int)\n"
    "    Fl_Button::value() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Button_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 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_Fl_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Button_set" "', argument " "1"" of type '" "Fl_Button *""'"); 
  }
  arg1 = (Fl_Button *)(argp1);
  {
    try {
      result = (int)(arg1)->set(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 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_Fl_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Button_clear" "', argument " "1"" of type '" "Fl_Button *""'"); 
  }
  arg1 = (Fl_Button *)(argp1);
  {
    try {
      result = (int)(arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_setonly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Button_setonly" "', argument " "1"" of type '" "Fl_Button *""'"); 
  }
  arg1 = (Fl_Button *)(argp1);
  {
    try {
      (arg1)->setonly(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_shortcut__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 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_Fl_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Button_shortcut" "', argument " "1"" of type '" "Fl_Button const *""'"); 
  }
  arg1 = (Fl_Button *)(argp1);
  {
    try {
      result = (int)((Fl_Button const *)arg1)->shortcut(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_shortcut__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 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_Fl_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Button_shortcut" "', argument " "1"" of type '" "Fl_Button *""'"); 
  }
  arg1 = (Fl_Button *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Button_shortcut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->shortcut(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_down_box__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Boxtype result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Button_down_box" "', argument " "1"" of type '" "Fl_Button const *""'"); 
  }
  arg1 = (Fl_Button *)(argp1);
  {
    try {
      result = (Fl_Boxtype)((Fl_Button const *)arg1)->down_box(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_down_box__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  Fl_Boxtype 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_Fl_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Button_down_box" "', argument " "1"" of type '" "Fl_Button *""'"); 
  }
  arg1 = (Fl_Button *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Button_down_box" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = (Fl_Boxtype)(val2);
  {
    try {
      (arg1)->down_box(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_down_box(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Button_down_box", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Button_down_box__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Button_down_box__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Button_down_box'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Button::down_box() const\n"
    "    Fl_Button::down_box(Fl_Boxtype)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Button_shortcut__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Button_shortcut" "', argument " "1"" of type '" "Fl_Button *""'"); 
  }
  arg1 = (Fl_Button *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Button_shortcut" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->shortcut((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_shortcut(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Button_shortcut", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Button_shortcut__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_Fl_Button_shortcut__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Button_shortcut__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Button_shortcut'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Button::shortcut() const\n"
    "    Fl_Button::shortcut(int)\n"
    "    Fl_Button::shortcut(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Button_down_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Button_down_color" "', argument " "1"" of type '" "Fl_Button const *""'"); 
  }
  arg1 = (Fl_Button *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Button const *)arg1)->down_color(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_down_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Button_down_color" "', argument " "1"" of type '" "Fl_Button *""'"); 
  }
  arg1 = (Fl_Button *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Button_down_color" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = (unsigned int)(val2);
  {
    try {
      (arg1)->down_color(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_down_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Button_down_color", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Button_down_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Button_down_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Button_down_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Button::down_color() const\n"
    "    Fl_Button::down_color(unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Button_compact__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Button_compact" "', argument " "1"" of type '" "Fl_Button *""'"); 
  }
  arg1 = (Fl_Button *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Button_compact" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  {
    try {
      (arg1)->compact(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_compact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Button_compact" "', argument " "1"" of type '" "Fl_Button *""'"); 
  }
  arg1 = (Fl_Button *)(argp1);
  {
    try {
      result = (uchar)(arg1)->compact(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_compact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Button_compact", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Button_compact__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Button_compact__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Button_compact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Button::compact(uchar)\n"
    "    Fl_Button::compact()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Button_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 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, "Fl_Button_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Button_init_type" "', argument " "1"" of type '" "Fl_Button *""'"); 
  }
  arg1 = (Fl_Button *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Button_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Button_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Button, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Button" "', argument " "1"" of type '" "Fl_Button *""'"); 
  }
  arg1 = (Fl_Button *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Button" "', argument " "1"" of type '" "Fl_Button *""'"); 
  }
  arg1 = (Fl_Button *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Shortcut_Button_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shortcut_Button *arg1 = (Fl_Shortcut_Button *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Shortcut_Button *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Shortcut_Button_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Shortcut_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shortcut_Button_handle" "', argument " "1"" of type '" "Fl_Shortcut_Button *""'"); 
  }
  arg1 = (Fl_Shortcut_Button *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Shortcut_Button_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("handle"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member handle");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Shortcut_Button *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)(darg)->handleSwigPublic(arg2);
        } else {
          result = (int)(darg)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shortcut_Button_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shortcut_Button *arg1 = (Fl_Shortcut_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Shortcut_Button *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Shortcut_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shortcut_Button_draw" "', argument " "1"" of type '" "Fl_Shortcut_Button *""'"); 
  }
  arg1 = (Fl_Shortcut_Button *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Shortcut_Button *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Shortcut_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Shortcut_Button *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Shortcut_Button", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Shortcut_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Shortcut_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Shortcut_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Shortcut_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Shortcut_Button" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Shortcut_Button *)new SwigDirector_Fl_Shortcut_Button(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Shortcut_Button *)new Fl_Shortcut_Button(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Shortcut_Button, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shortcut_Button_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Shortcut_Button *arg1 = (Fl_Shortcut_Button *) 0 ;
  Fl_Shortcut arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Shortcut_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shortcut_Button_value" "', argument " "1"" of type '" "Fl_Shortcut_Button *""'"); 
  }
  arg1 = (Fl_Shortcut_Button *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Shortcut_Button_value" "', argument " "2"" of type '" "Fl_Shortcut""'");
  } 
  arg2 = (Fl_Shortcut)(val2);
  {
    try {
      (arg1)->value(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shortcut_Button_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Shortcut_Button *arg1 = (Fl_Shortcut_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Shortcut result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Shortcut_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shortcut_Button_value" "', argument " "1"" of type '" "Fl_Shortcut_Button *""'"); 
  }
  arg1 = (Fl_Shortcut_Button *)(argp1);
  {
    try {
      result = (Fl_Shortcut)(arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shortcut_Button_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Shortcut_Button_value", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Shortcut_Button_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Shortcut_Button_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Shortcut_Button_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Shortcut_Button::value(Fl_Shortcut)\n"
    "    Fl_Shortcut_Button::value()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Shortcut_Button_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shortcut_Button *arg1 = (Fl_Shortcut_Button *) 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, "Fl_Shortcut_Button_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Shortcut_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shortcut_Button_init_type" "', argument " "1"" of type '" "Fl_Shortcut_Button *""'"); 
  }
  arg1 = (Fl_Shortcut_Button *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Shortcut_Button_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Shortcut_Button_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Shortcut_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shortcut_Button *arg1 = (Fl_Shortcut_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Shortcut_Button, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Shortcut_Button" "', argument " "1"" of type '" "Fl_Shortcut_Button *""'"); 
  }
  arg1 = (Fl_Shortcut_Button *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Shortcut_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shortcut_Button *arg1 = (Fl_Shortcut_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Shortcut_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Shortcut_Button" "', argument " "1"" of type '" "Fl_Shortcut_Button *""'"); 
  }
  arg1 = (Fl_Shortcut_Button *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_FL_CHART_ENTRY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FL_CHART_ENTRY *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_FL_CHART_ENTRY", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (FL_CHART_ENTRY *)new FL_CHART_ENTRY(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FL_CHART_ENTRY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FL_CHART_ENTRY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FL_CHART_ENTRY *arg1 = (FL_CHART_ENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FL_CHART_ENTRY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FL_CHART_ENTRY" "', argument " "1"" of type '" "FL_CHART_ENTRY *""'"); 
  }
  arg1 = (FL_CHART_ENTRY *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Chart_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Chart *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_draw" "', argument " "1"" of type '" "Fl_Chart *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Chart *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Chart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Chart *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Chart", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Chart" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Chart" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Chart" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Chart" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Chart" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Chart *)new SwigDirector_Fl_Chart(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Chart *)new Fl_Chart(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Chart, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Chart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Chart, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Chart" "', argument " "1"" of type '" "Fl_Chart *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_clear" "', argument " "1"" of type '" "Fl_Chart *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_add(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  double arg2 ;
  char *arg3 = (char *) 0 ;
  unsigned int arg4 = (unsigned int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Chart_add", 2, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_add" "', argument " "1"" of type '" "Fl_Chart *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_add" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  if (swig_obj[2]) {
    res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Chart_add" "', argument " "3"" of type '" "char const *""'");
    }
    arg3 = (char *)(buf3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Chart_add" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = (unsigned int)(val4);
  }
  {
    try {
      (arg1)->add(arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  int arg2 ;
  double arg3 ;
  char *arg4 = (char *) 0 ;
  unsigned int arg5 = (unsigned int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Chart_insert", 3, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_insert" "', argument " "1"" of type '" "Fl_Chart *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_insert" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Chart_insert" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  if (swig_obj[3]) {
    res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Chart_insert" "', argument " "4"" of type '" "char const *""'");
    }
    arg4 = (char *)(buf4);
  }
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Chart_insert" "', argument " "5"" of type '" "unsigned int""'");
    } 
    arg5 = (unsigned int)(val5);
  }
  {
    try {
      (arg1)->insert(arg2,arg3,(char const *)arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_replace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  int arg2 ;
  double arg3 ;
  char *arg4 = (char *) 0 ;
  unsigned int arg5 = (unsigned int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Chart_replace", 3, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_replace" "', argument " "1"" of type '" "Fl_Chart *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_replace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Chart_replace" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  if (swig_obj[3]) {
    res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Chart_replace" "', argument " "4"" of type '" "char const *""'");
    }
    arg4 = (char *)(buf4);
  }
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Chart_replace" "', argument " "5"" of type '" "unsigned int""'");
    } 
    arg5 = (unsigned int)(val5);
  }
  {
    try {
      (arg1)->replace(arg2,arg3,(char const *)arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_bounds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  double *arg2 = (double *) 0 ;
  double *arg3 = (double *) 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_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_bounds" "', argument " "1"" of type '" "Fl_Chart const *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Chart_bounds" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Chart_bounds" "', argument " "3"" of type '" "double *""'"); 
  }
  arg3 = (double *)(argp3);
  {
    try {
      ((Fl_Chart const *)arg1)->bounds(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_bounds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_bounds" "', argument " "1"" of type '" "Fl_Chart *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_bounds" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Chart_bounds" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  {
    try {
      (arg1)->bounds(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_bounds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Chart_bounds", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Chart_bounds__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Chart_bounds__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Chart_bounds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Chart::bounds(double *,double *) const\n"
    "    Fl_Chart::bounds(double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 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_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_size" "', argument " "1"" of type '" "Fl_Chart const *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  {
    try {
      result = (int)((Fl_Chart const *)arg1)->size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 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_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_size" "', argument " "1"" of type '" "Fl_Chart *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Chart_size" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->size(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Chart_size", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Chart_size__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Chart_size__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Chart_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Chart::size() const\n"
    "    Fl_Chart::size(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_maxsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 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_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_maxsize" "', argument " "1"" of type '" "Fl_Chart const *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  {
    try {
      result = (int)((Fl_Chart const *)arg1)->maxsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_maxsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 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_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_maxsize" "', argument " "1"" of type '" "Fl_Chart *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_maxsize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->maxsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_maxsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Chart_maxsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Chart_maxsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Chart_maxsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Chart_maxsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Chart::maxsize() const\n"
    "    Fl_Chart::maxsize(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_textfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_textfont" "', argument " "1"" of type '" "Fl_Chart const *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Chart const *)arg1)->textfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_textfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  Fl_Font 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_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_textfont" "', argument " "1"" of type '" "Fl_Chart *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->textfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_textfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Chart_textfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Chart_textfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Chart_textfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Chart_textfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Chart::textfont() const\n"
    "    Fl_Chart::textfont(Fl_Font)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_textsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_textsize" "', argument " "1"" of type '" "Fl_Chart const *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Chart const *)arg1)->textsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_textsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  Fl_Fontsize 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_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_textsize" "', argument " "1"" of type '" "Fl_Chart *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->textsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_textsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Chart_textsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Chart_textsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Chart_textsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Chart_textsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Chart::textsize() const\n"
    "    Fl_Chart::textsize(Fl_Fontsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_textcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_textcolor" "', argument " "1"" of type '" "Fl_Chart const *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Chart const *)arg1)->textcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_textcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_textcolor" "', argument " "1"" of type '" "Fl_Chart *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->textcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_textcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Chart_textcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Chart_textcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Chart_textcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Chart_textcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Chart::textcolor() const\n"
    "    Fl_Chart::textcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_autosize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_autosize" "', argument " "1"" of type '" "Fl_Chart const *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  {
    try {
      result = (uchar)((Fl_Chart const *)arg1)->autosize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_autosize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_autosize" "', argument " "1"" of type '" "Fl_Chart *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_autosize" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  {
    try {
      (arg1)->autosize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_autosize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Chart_autosize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Chart_autosize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Chart_autosize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Chart_autosize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Chart::autosize() const\n"
    "    Fl_Chart::autosize(uchar)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 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, "Fl_Chart_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Chart_init_type" "', argument " "1"" of type '" "Fl_Chart *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Chart_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Chart_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Chart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Chart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Chart" "', argument " "1"" of type '" "Fl_Chart *""'"); 
  }
  arg1 = (Fl_Chart *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_first(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_item_first" "', argument " "1"" of type '" "Fl_Check_Browser const *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_first"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_first");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Check_Browser const *)darg)->item_firstSwigPublic();
        } else {
          result = (void *)((SwigDirector_Fl_Check_Browser const *)darg)->item_first();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Check_Browser_item_next", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_item_next" "', argument " "1"" of type '" "Fl_Check_Browser const *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(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 '" "Fl_Check_Browser_item_next" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_next"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_next");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Check_Browser const *)darg)->item_nextSwigPublic(arg2);
        } else {
          result = (void *)((SwigDirector_Fl_Check_Browser const *)darg)->item_next(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_prev(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Check_Browser_item_prev", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_item_prev" "', argument " "1"" of type '" "Fl_Check_Browser const *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(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 '" "Fl_Check_Browser_item_prev" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_prev"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_prev");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Check_Browser const *)darg)->item_prevSwigPublic(arg2);
        } else {
          result = (void *)((SwigDirector_Fl_Check_Browser const *)darg)->item_prev(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Check_Browser_item_height", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_item_height" "', argument " "1"" of type '" "Fl_Check_Browser const *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(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 '" "Fl_Check_Browser_item_height" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Check_Browser const *)darg)->item_heightSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Check_Browser const *)darg)->item_height(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_width(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Check_Browser_item_width", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_item_width" "', argument " "1"" of type '" "Fl_Check_Browser const *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(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 '" "Fl_Check_Browser_item_width" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_width"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_width");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Check_Browser const *)darg)->item_widthSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Check_Browser const *)darg)->item_width(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Check_Browser_item_draw", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_item_draw" "', argument " "1"" of type '" "Fl_Check_Browser const *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(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 '" "Fl_Check_Browser_item_draw" "', 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 '" "Fl_Check_Browser_item_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Check_Browser_item_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Check_Browser_item_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Check_Browser_item_draw" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    {
      try {
        if (upcall) {
          ((SwigDirector_Fl_Check_Browser const *)darg)->item_drawSwigPublic(arg2,arg3,arg4,arg5,arg6);
        } else {
          ((SwigDirector_Fl_Check_Browser const *)darg)->item_draw(arg2,arg3,arg4,arg5,arg6);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_select(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Check_Browser_item_select", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_item_select" "', argument " "1"" of type '" "Fl_Check_Browser *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(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 '" "Fl_Check_Browser_item_select" "', 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 '" "Fl_Check_Browser_item_select" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_select"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_select");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->item_selectSwigPublic(arg2,arg3);
        } else {
          (darg)->item_select(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_selected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Check_Browser_item_selected", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_item_selected" "', argument " "1"" of type '" "Fl_Check_Browser const *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(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 '" "Fl_Check_Browser_item_selected" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_selected"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_selected");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Check_Browser const *)darg)->item_selectedSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Check_Browser const *)darg)->item_selected(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_text(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Check_Browser_item_text", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_item_text" "', argument " "1"" of type '" "Fl_Check_Browser const *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(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 '" "Fl_Check_Browser_item_text" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_text"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_text");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (char *)((SwigDirector_Fl_Check_Browser const *)darg)->item_textSwigPublic(arg2);
        } else {
          result = (char *)((SwigDirector_Fl_Check_Browser const *)darg)->item_text(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (director) {
    director->swig_release_ownership(SWIG_as_voidptr(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_at(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Check_Browser_item_at", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_item_at" "', argument " "1"" of type '" "Fl_Check_Browser const *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Check_Browser_item_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (void *)((Fl_Check_Browser const *)arg1)->Fl_Check_Browser::item_at(arg2);
        } else {
          result = (void *)((Fl_Check_Browser const *)arg1)->item_at(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_swap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 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_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_item_swap" "', argument " "1"" of type '" "Fl_Check_Browser *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Check_Browser_item_swap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Check_Browser_item_swap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->item_swap(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_swap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_item_swap" "', argument " "1"" of type '" "Fl_Check_Browser *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(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 '" "Fl_Check_Browser_item_swap" "', argument " "2"" of type '" "void *""'"); 
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Check_Browser_item_swap" "', argument " "3"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Check_Browser::item_swap(arg2,arg3);
        } else {
          (arg1)->item_swap(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_swap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Check_Browser_item_swap", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Check_Browser_item_swap__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Check_Browser_item_swap__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Check_Browser_item_swap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Check_Browser::item_swap(int,int)\n"
    "    Fl_Check_Browser::item_swap(void *,void *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Fl_Check_Browser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Check_Browser *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Check_Browser", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Check_Browser" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Check_Browser" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Check_Browser" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Check_Browser" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Check_Browser" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Check_Browser *)new SwigDirector_Fl_Check_Browser(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Check_Browser *)new Fl_Check_Browser(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Check_Browser, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Check_Browser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Check_Browser" "', argument " "1"" of type '" "Fl_Check_Browser *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 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, "Fl_Check_Browser_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_remove" "', argument " "1"" of type '" "Fl_Check_Browser *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Check_Browser_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)(arg1)->remove(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_add__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  char *arg2 = (char *) 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_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_add" "', argument " "1"" of type '" "Fl_Check_Browser *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Check_Browser_add" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)(arg1)->add((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_add__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  char *arg2 = (char *) 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_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_add" "', argument " "1"" of type '" "Fl_Check_Browser *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Check_Browser_add" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Check_Browser_add" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)(arg1)->add((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Check_Browser_add", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Check_Browser_add__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Check_Browser_add__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Check_Browser_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Check_Browser::add(char const *)\n"
    "    Fl_Check_Browser::add(char const *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_clear" "', argument " "1"" of type '" "Fl_Check_Browser *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_nitems(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 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_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_nitems" "', argument " "1"" of type '" "Fl_Check_Browser const *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  {
    try {
      result = (int)((Fl_Check_Browser const *)arg1)->nitems(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_nchecked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 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_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_nchecked" "', argument " "1"" of type '" "Fl_Check_Browser const *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  {
    try {
      result = (int)((Fl_Check_Browser const *)arg1)->nchecked(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_checked__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 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_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_checked" "', argument " "1"" of type '" "Fl_Check_Browser const *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Check_Browser_checked" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Check_Browser const *)arg1)->checked(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_checked__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 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_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_checked" "', argument " "1"" of type '" "Fl_Check_Browser *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Check_Browser_checked" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Check_Browser_checked" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->checked(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_checked(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Check_Browser_checked", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Check_Browser_checked__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Check_Browser_checked__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Check_Browser_checked'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Check_Browser::checked(int) const\n"
    "    Fl_Check_Browser::checked(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_set_checked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 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, "Fl_Check_Browser_set_checked", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_set_checked" "', argument " "1"" of type '" "Fl_Check_Browser *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Check_Browser_set_checked" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->set_checked(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_check_all(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_check_all" "', argument " "1"" of type '" "Fl_Check_Browser *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  {
    try {
      (arg1)->check_all(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_check_none(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_check_none" "', argument " "1"" of type '" "Fl_Check_Browser *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  {
    try {
      (arg1)->check_none(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 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_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_value" "', argument " "1"" of type '" "Fl_Check_Browser const *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  {
    try {
      result = (int)((Fl_Check_Browser const *)arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_text(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 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, "Fl_Check_Browser_text", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_text" "', argument " "1"" of type '" "Fl_Check_Browser const *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Check_Browser_text" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (char *)((Fl_Check_Browser const *)arg1)->text(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Check_Browser_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_handle" "', argument " "1"" of type '" "Fl_Check_Browser *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Check_Browser_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("handle"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member handle");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)(darg)->handleSwigPublic(arg2);
        } else {
          result = (int)(darg)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 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, "Fl_Check_Browser_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_init_type" "', argument " "1"" of type '" "Fl_Check_Browser *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Check_Browser_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Check_Browser_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Check_Browser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Check_Browser" "', argument " "1"" of type '" "Fl_Check_Browser *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_draw" "', argument " "1"" of type '" "Fl_Check_Browser *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_last(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_item_last" "', argument " "1"" of type '" "Fl_Check_Browser const *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_last"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_last");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Check_Browser const *)darg)->item_lastSwigPublic();
        } else {
          result = (void *)((SwigDirector_Fl_Check_Browser const *)darg)->item_last();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_quick_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Check_Browser_item_quick_height", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_item_quick_height" "', argument " "1"" of type '" "Fl_Check_Browser const *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(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 '" "Fl_Check_Browser_item_quick_height" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_quick_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_quick_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Check_Browser const *)darg)->item_quick_heightSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Check_Browser const *)darg)->item_quick_height(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_full_width(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_full_width" "', argument " "1"" of type '" "Fl_Check_Browser const *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("full_width"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member full_width");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Check_Browser const *)darg)->full_widthSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Check_Browser const *)darg)->full_width();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_full_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_full_height" "', argument " "1"" of type '" "Fl_Check_Browser const *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("full_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member full_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Check_Browser const *)darg)->full_heightSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Check_Browser const *)darg)->full_height();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_incr_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Browser_incr_height" "', argument " "1"" of type '" "Fl_Check_Browser const *""'"); 
  }
  arg1 = (Fl_Check_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("incr_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member incr_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Check_Browser const *)darg)->incr_heightSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Check_Browser const *)darg)->incr_height();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Light_Button_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Light_Button *arg1 = (Fl_Light_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Light_Button *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Light_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Light_Button_draw" "', argument " "1"" of type '" "Fl_Light_Button *""'"); 
  }
  arg1 = (Fl_Light_Button *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Light_Button *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Light_Button_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Light_Button *arg1 = (Fl_Light_Button *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Light_Button_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Light_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Light_Button_handle" "', argument " "1"" of type '" "Fl_Light_Button *""'"); 
  }
  arg1 = (Fl_Light_Button *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Light_Button_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Light_Button::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Light_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Light_Button *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Light_Button", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Light_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Light_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Light_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Light_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Light_Button" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Light_Button *)new SwigDirector_Fl_Light_Button(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Light_Button *)new Fl_Light_Button(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Light_Button, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Light_Button_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Light_Button *arg1 = (Fl_Light_Button *) 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, "Fl_Light_Button_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Light_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Light_Button_init_type" "', argument " "1"" of type '" "Fl_Light_Button *""'"); 
  }
  arg1 = (Fl_Light_Button *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Light_Button_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Light_Button_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Light_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Light_Button *arg1 = (Fl_Light_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Light_Button, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Light_Button" "', argument " "1"" of type '" "Fl_Light_Button *""'"); 
  }
  arg1 = (Fl_Light_Button *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Light_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Light_Button *arg1 = (Fl_Light_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Light_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Light_Button" "', argument " "1"" of type '" "Fl_Light_Button *""'"); 
  }
  arg1 = (Fl_Light_Button *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Check_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Check_Button *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Check_Button", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Check_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Check_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Check_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Check_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Check_Button" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Check_Button *)new SwigDirector_Fl_Check_Button(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Check_Button *)new Fl_Check_Button(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Check_Button, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Button_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Button *arg1 = (Fl_Check_Button *) 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, "Fl_Check_Button_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Button_init_type" "', argument " "1"" of type '" "Fl_Check_Button *""'"); 
  }
  arg1 = (Fl_Check_Button *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Check_Button_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Check_Button_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Check_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Button *arg1 = (Fl_Check_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Button, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Check_Button" "', argument " "1"" of type '" "Fl_Check_Button *""'"); 
  }
  arg1 = (Fl_Check_Button *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Check_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Button *arg1 = (Fl_Check_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Check_Button" "', argument " "1"" of type '" "Fl_Check_Button *""'"); 
  }
  arg1 = (Fl_Check_Button *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Button_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Button *arg1 = (Fl_Check_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Button *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Check_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Check_Button_draw" "', argument " "1"" of type '" "Fl_Check_Button *""'"); 
  }
  arg1 = (Fl_Check_Button *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Button *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Menu_(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Menu_ *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Menu_", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Menu_" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Menu_" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Menu_" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Menu_" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Menu_" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Menu_ *)new SwigDirector_Fl_Menu_(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
        SWIG_fail;
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Menu_(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Menu_" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__item_pathname(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  Fl_Menu_Item *arg4 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Menu__item_pathname", 3, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__item_pathname" "', argument " "1"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu__item_pathname" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu__item_pathname" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  if (swig_obj[3]) {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Menu__item_pathname" "', argument " "4"" of type '" "Fl_Menu_Item const *""'"); 
    }
    arg4 = (Fl_Menu_Item *)(argp4);
  }
  {
    try {
      result = (int)((Fl_Menu_ const *)arg1)->item_pathname(arg2,arg3,(Fl_Menu_Item const *)arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__picked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  Fl_Menu_Item *arg2 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Menu__picked", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__picked" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu__picked" "', argument " "2"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg2 = (Fl_Menu_Item *)(argp2);
  {
    try {
      result = (Fl_Menu_Item *)(arg1)->picked((Fl_Menu_Item const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__find_item__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__find_item" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu__find_item" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (Fl_Menu_Item *)(arg1)->find_item((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__find_item__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  Fl_Callback *arg2 = (Fl_Callback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__find_item" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Menu__find_item" "', argument " "2"" of type '" "Fl_Callback *""'"); 
    }
  }
  {
    try {
      result = (Fl_Menu_Item *)(arg1)->find_item(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__find_item(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu__find_item", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Menu__find_item__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu__find_item__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu__find_item'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_::find_item(char const *)\n"
    "    Fl_Menu_::find_item(Fl_Callback *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__find_item_with_user_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Menu__find_item_with_user_data", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__find_item_with_user_data" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(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 '" "Fl_Menu__find_item_with_user_data" "', argument " "2"" of type '" "void *""'"); 
  }
  {
    try {
      result = (Fl_Menu_Item *)(arg1)->find_item_with_user_data(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__find_item_with_argument(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Menu__find_item_with_argument", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__find_item_with_argument" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__find_item_with_argument" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = (long)(val2);
  {
    try {
      result = (Fl_Menu_Item *)(arg1)->find_item_with_argument(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__find_index__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  char *arg2 = (char *) 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_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__find_index" "', argument " "1"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu__find_index" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)((Fl_Menu_ const *)arg1)->find_index((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__find_index__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  Fl_Menu_Item *arg2 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__find_index" "', argument " "1"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu__find_index" "', argument " "2"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg2 = (Fl_Menu_Item *)(argp2);
  {
    try {
      result = (int)((Fl_Menu_ const *)arg1)->find_index((Fl_Menu_Item const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__find_index__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  Fl_Callback *arg2 = (Fl_Callback *) 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_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__find_index" "', argument " "1"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Menu__find_index" "', argument " "2"" of type '" "Fl_Callback *""'"); 
    }
  }
  {
    try {
      result = (int)((Fl_Menu_ const *)arg1)->find_index(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__find_index(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu__find_index", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Menu_Item, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Menu__find_index__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_Fl_Menu__find_index__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu__find_index__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu__find_index'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_::find_index(char const *) const\n"
    "    Fl_Menu_::find_index(Fl_Menu_Item const *) const\n"
    "    Fl_Menu_::find_index(Fl_Callback *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__test_shortcut(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__test_shortcut" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    try {
      result = (Fl_Menu_Item *)(arg1)->test_shortcut(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__menu__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__menu" "', argument " "1"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    try {
      result = (Fl_Menu_Item *)((Fl_Menu_ const *)arg1)->menu(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__menu_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__menu_end" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    try {
      result = (Fl_Menu_Item *)(arg1)->menu_end(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__copy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  Fl_Menu_Item *arg2 = (Fl_Menu_Item *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__copy" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu__copy" "', argument " "2"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg2 = (Fl_Menu_Item *)(argp2);
  if (swig_obj[2]) {
    res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Menu__copy" "', argument " "3"" of type '" "void *""'"); 
    }
  }
  {
    try {
      (arg1)->copy((Fl_Menu_Item const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  Fl_Callback *arg5 = (Fl_Callback *) 0 ;
  void *arg6 = (void *) 0 ;
  int arg7 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int res6 ;
  int val7 ;
  int ecode7 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__insert" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__insert" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Menu__insert" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Menu__insert" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[4], (void**)(&arg5), SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Menu__insert" "', argument " "5"" of type '" "Fl_Callback *""'"); 
    }
  }
  if (swig_obj[5]) {
    res6 = SWIG_ConvertPtr(swig_obj[5],SWIG_as_voidptrptr(&arg6), 0, 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Fl_Menu__insert" "', argument " "6"" of type '" "void *""'"); 
    }
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Menu__insert" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  {
    try {
      result = (int)(arg1)->insert(arg2,(char const *)arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__add__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  Fl_Callback *arg4 = (Fl_Callback *) 0 ;
  void *arg5 = (void *) 0 ;
  int arg6 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res5 ;
  int val6 ;
  int ecode6 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__add" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu__add" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu__add" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[3], (void**)(&arg4), SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Menu__add" "', argument " "4"" of type '" "Fl_Callback *""'"); 
    }
  }
  if (swig_obj[4]) {
    res5 = SWIG_ConvertPtr(swig_obj[4],SWIG_as_voidptrptr(&arg5), 0, 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Fl_Menu__add" "', argument " "5"" of type '" "void *""'"); 
    }
  }
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Menu__add" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  {
    try {
      result = (int)(arg1)->add((char const *)arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  Fl_Callback *arg5 = (Fl_Callback *) 0 ;
  void *arg6 = (void *) 0 ;
  int arg7 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int res6 ;
  int val7 ;
  int ecode7 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__insert" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__insert" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Menu__insert" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Menu__insert" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = (char *)(buf4);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[4], (void**)(&arg5), SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Menu__insert" "', argument " "5"" of type '" "Fl_Callback *""'"); 
    }
  }
  if (swig_obj[5]) {
    res6 = SWIG_ConvertPtr(swig_obj[5],SWIG_as_voidptrptr(&arg6), 0, 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Fl_Menu__insert" "', argument " "6"" of type '" "void *""'"); 
    }
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Menu__insert" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  {
    try {
      result = (int)(arg1)->insert(arg2,(char const *)arg3,(char const *)arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu__insert", 0, 7, argv))) SWIG_fail;
  --argc;
  if ((argc >= 5) && (argc <= 7)) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[3], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_Fl_Menu__insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if ((argc >= 5) && (argc <= 7)) {
    PyObject *retobj = _wrap_Fl_Menu__insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu__insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_::insert(int,char const *,int,Fl_Callback *,void *,int)\n"
    "    Fl_Menu_::insert(int,char const *,char const *,Fl_Callback *,void *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__add__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  char *arg2 = (char *) 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_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__add" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu__add" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)(arg1)->add((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 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_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__size" "', argument " "1"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    try {
      result = (int)((Fl_Menu_ const *)arg1)->size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 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_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__size" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu__size" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->size(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu__size", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu__size__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Menu__size__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu__size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_::size() const\n"
    "    Fl_Menu_::size(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__clear" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__clear_submenu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 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, "Fl_Menu__clear_submenu", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__clear_submenu" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__clear_submenu" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)(arg1)->clear_submenu(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__replace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Menu__replace", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__replace" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__replace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Menu__replace" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      (arg1)->replace(arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 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, "Fl_Menu__remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__remove" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->remove(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__shortcut(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 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, "Fl_Menu__shortcut", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__shortcut" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__shortcut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu__shortcut" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->shortcut(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__mode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 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_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__mode" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu__mode" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->mode(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__mode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 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_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__mode" "', argument " "1"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Menu_ const *)arg1)->mode(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__mode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu__mode", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu__mode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Menu__mode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu__mode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_::mode(int,int)\n"
    "    Fl_Menu_::mode(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__mvalue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__mvalue" "', argument " "1"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    try {
      result = (Fl_Menu_Item *)((Fl_Menu_ const *)arg1)->mvalue(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__prev_mvalue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__prev_mvalue" "', argument " "1"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    try {
      result = (Fl_Menu_Item *)((Fl_Menu_ const *)arg1)->prev_mvalue(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 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_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__value" "', argument " "1"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    try {
      result = (int)((Fl_Menu_ const *)arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 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_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__value" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)(arg1)->value(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu__value", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu__value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu__value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu__value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_::value() const\n"
    "    Fl_Menu_::value(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__text__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__text" "', argument " "1"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    try {
      result = (char *)((Fl_Menu_ const *)arg1)->text(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__text__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__text" "', argument " "1"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__text" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (char *)((Fl_Menu_ const *)arg1)->text(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__text(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu__text", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu__text__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu__text__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu__text'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_::text() const\n"
    "    Fl_Menu_::text(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__textfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__textfont" "', argument " "1"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Menu_ const *)arg1)->textfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__textfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  Fl_Font 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_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__textfont" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->textfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__textfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu__textfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu__textfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu__textfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu__textfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_::textfont() const\n"
    "    Fl_Menu_::textfont(Fl_Font)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__textsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__textsize" "', argument " "1"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Menu_ const *)arg1)->textsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__textsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  Fl_Fontsize 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_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__textsize" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->textsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__textsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu__textsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu__textsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu__textsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu__textsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_::textsize() const\n"
    "    Fl_Menu_::textsize(Fl_Fontsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__textcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__textcolor" "', argument " "1"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Menu_ const *)arg1)->textcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__textcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__textcolor" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->textcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__textcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu__textcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu__textcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu__textcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu__textcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_::textcolor() const\n"
    "    Fl_Menu_::textcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__down_box__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Boxtype result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__down_box" "', argument " "1"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    try {
      result = (Fl_Boxtype)((Fl_Menu_ const *)arg1)->down_box(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__down_box__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  Fl_Boxtype 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_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__down_box" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__down_box" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = (Fl_Boxtype)(val2);
  {
    try {
      (arg1)->down_box(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__down_box(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu__down_box", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu__down_box__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu__down_box__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu__down_box'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_::down_box() const\n"
    "    Fl_Menu_::down_box(Fl_Boxtype)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__menu_box__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Boxtype result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__menu_box" "', argument " "1"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    try {
      result = (Fl_Boxtype)((Fl_Menu_ const *)arg1)->menu_box(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__menu_box__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  Fl_Boxtype 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_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__menu_box" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__menu_box" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = (Fl_Boxtype)(val2);
  {
    try {
      (arg1)->menu_box(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__menu_box(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu__menu_box", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu__menu_box__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu__menu_box__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu__menu_box'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_::menu_box() const\n"
    "    Fl_Menu_::menu_box(Fl_Boxtype)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__down_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__down_color" "', argument " "1"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Menu_ const *)arg1)->down_color(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__down_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__down_color" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__down_color" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = (unsigned int)(val2);
  {
    try {
      (arg1)->down_color(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__down_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu__down_color", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu__down_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu__down_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu__down_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_::down_color() const\n"
    "    Fl_Menu_::down_color(unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__setonly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  Fl_Menu_Item *arg2 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Menu__setonly", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__setonly" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu__setonly" "', argument " "2"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg2 = (Fl_Menu_Item *)(argp2);
  {
    try {
      (arg1)->setonly(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 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, "Fl_Menu__init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__init_type" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu__init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Menu__init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__copy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__copy" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  arg2 = swig_obj[1];
  if (swig_obj[2]) {
    arg3 = swig_obj[2];
  }
  {
    try {
      Fl_Menu__copy__SWIG_1(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__copy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu__copy", 0, 3, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Menu_Item, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    if (argc > 2) {
      {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
      }
      if (!_v) goto check_1;
    }
    return _wrap_Fl_Menu__copy__SWIG_0(self, argc, argv);
  }
check_1:
  
  if ((argc >= 2) && (argc <= 3)) {
    PyObject *retobj = _wrap_Fl_Menu__copy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu__copy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_::copy(Fl_Menu_Item const *,void *)\n"
    "    Fl_Menu_::copy(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__menu__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  PyObject *arg2 = (PyObject *) 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_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__menu" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  arg2 = swig_obj[1];
  {
    try {
      Fl_Menu__menu__SWIG_1(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__add__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  PyObject *arg4 = (PyObject *) 0 ;
  PyObject *arg5 = (PyObject *) 0 ;
  PyObject *arg6 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__add" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  arg4 = swig_obj[3];
  if (swig_obj[4]) {
    arg5 = swig_obj[4];
  }
  if (swig_obj[5]) {
    arg6 = swig_obj[5];
  }
  {
    try {
      result = (int)Fl_Menu__add__SWIG_2(arg1,arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu__add", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu__add__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 4) && (argc <= 6)) {
    int _v = 0;
    {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[3], &ptr, SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    if (argc > 4) {
      {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
      }
      if (!_v) goto check_2;
      if (argc > 5) {
        {
          {
            int res = SWIG_AsVal_int(argv[5], NULL);
            _v = SWIG_CheckState(res);
          }
        }
        if (!_v) goto check_2;
      }
    }
    return _wrap_Fl_Menu__add__SWIG_0(self, argc, argv);
  }
check_2:
  
  if ((argc >= 4) && (argc <= 6)) {
    PyObject *retobj = _wrap_Fl_Menu__add__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu__add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_::add(char const *,int,Fl_Callback *,void *,int)\n"
    "    Fl_Menu_::add(char const *)\n"
    "    Fl_Menu_::add(PyObject *,PyObject *,PyObject *,PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__menu__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu__menu" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    try {
      result = (PyObject *)Fl_Menu__menu__SWIG_2(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__menu(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu__menu", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu__menu__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu__menu__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu__menu__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu__menu'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_::menu() const\n"
    "    Fl_Menu_::menu(PyObject *)\n"
    "    Fl_Menu_::menu()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Menu_(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Menu_" "', argument " "1"" of type '" "Fl_Menu_ *""'"); 
  }
  arg1 = (Fl_Menu_ *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Choice_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Choice *arg1 = (Fl_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Choice *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Choice_draw" "', argument " "1"" of type '" "Fl_Choice *""'"); 
  }
  arg1 = (Fl_Choice *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Choice *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Choice_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Choice *arg1 = (Fl_Choice *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Choice_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Choice_handle" "', argument " "1"" of type '" "Fl_Choice *""'"); 
  }
  arg1 = (Fl_Choice *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Choice_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Choice::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Choice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Choice *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Choice", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Choice" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Choice" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Choice" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Choice" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Choice" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Choice *)new SwigDirector_Fl_Choice(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Choice *)new Fl_Choice(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Choice, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Choice_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Choice *arg1 = (Fl_Choice *) 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_Fl_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Choice_value" "', argument " "1"" of type '" "Fl_Choice const *""'"); 
  }
  arg1 = (Fl_Choice *)(argp1);
  {
    try {
      result = (int)((Fl_Choice const *)arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Choice_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Choice *arg1 = (Fl_Choice *) 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_Fl_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Choice_value" "', argument " "1"" of type '" "Fl_Choice *""'"); 
  }
  arg1 = (Fl_Choice *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Choice_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)(arg1)->value(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Choice_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Choice_value", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Choice_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Choice_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Choice_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Choice::value() const\n"
    "    Fl_Choice::value(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Choice_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Choice *arg1 = (Fl_Choice *) 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, "Fl_Choice_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Choice_init_type" "', argument " "1"" of type '" "Fl_Choice *""'"); 
  }
  arg1 = (Fl_Choice *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Choice_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Choice_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Choice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Choice *arg1 = (Fl_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Choice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Choice" "', argument " "1"" of type '" "Fl_Choice *""'"); 
  }
  arg1 = (Fl_Choice *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Choice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Choice *arg1 = (Fl_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Choice" "', argument " "1"" of type '" "Fl_Choice *""'"); 
  }
  arg1 = (Fl_Choice *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Copy_Surface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Fl_Copy_Surface *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Copy_Surface", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Fl_Copy_Surface" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Copy_Surface" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (Fl_Copy_Surface *)new Fl_Copy_Surface(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Copy_Surface, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Copy_Surface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Copy_Surface *arg1 = (Fl_Copy_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Copy_Surface, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Copy_Surface" "', argument " "1"" of type '" "Fl_Copy_Surface *""'"); 
  }
  arg1 = (Fl_Copy_Surface *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Copy_Surface_set_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Copy_Surface *arg1 = (Fl_Copy_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Copy_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Copy_Surface_set_current" "', argument " "1"" of type '" "Fl_Copy_Surface *""'"); 
  }
  arg1 = (Fl_Copy_Surface *)(argp1);
  {
    try {
      (arg1)->set_current(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Copy_Surface_is_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Copy_Surface *arg1 = (Fl_Copy_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Copy_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Copy_Surface_is_current" "', argument " "1"" of type '" "Fl_Copy_Surface *""'"); 
  }
  arg1 = (Fl_Copy_Surface *)(argp1);
  {
    try {
      result = (bool)(arg1)->is_current(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Copy_Surface_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Copy_Surface *arg1 = (Fl_Copy_Surface *) 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_Fl_Copy_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Copy_Surface_w" "', argument " "1"" of type '" "Fl_Copy_Surface *""'"); 
  }
  arg1 = (Fl_Copy_Surface *)(argp1);
  {
    try {
      result = (int)(arg1)->w(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Copy_Surface_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Copy_Surface *arg1 = (Fl_Copy_Surface *) 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_Fl_Copy_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Copy_Surface_h" "', argument " "1"" of type '" "Fl_Copy_Surface *""'"); 
  }
  arg1 = (Fl_Copy_Surface *)(argp1);
  {
    try {
      result = (int)(arg1)->h(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Copy_Surface_origin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Copy_Surface *arg1 = (Fl_Copy_Surface *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 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_Fl_Copy_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Copy_Surface_origin" "', argument " "1"" of type '" "Fl_Copy_Surface *""'"); 
  }
  arg1 = (Fl_Copy_Surface *)(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 '" "Fl_Copy_Surface_origin" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (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 '" "Fl_Copy_Surface_origin" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  {
    try {
      (arg1)->origin(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Copy_Surface_origin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Copy_Surface *arg1 = (Fl_Copy_Surface *) 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_Fl_Copy_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Copy_Surface_origin" "', argument " "1"" of type '" "Fl_Copy_Surface *""'"); 
  }
  arg1 = (Fl_Copy_Surface *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Copy_Surface_origin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Copy_Surface_origin" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->origin(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Copy_Surface_origin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Copy_Surface_origin", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Copy_Surface_origin__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Copy_Surface_origin__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Copy_Surface_origin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Copy_Surface::origin(int *,int *)\n"
    "    Fl_Copy_Surface::origin(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Copy_Surface_printable_rect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Copy_Surface *arg1 = (Fl_Copy_Surface *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Copy_Surface_printable_rect", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Copy_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Copy_Surface_printable_rect" "', argument " "1"" of type '" "Fl_Copy_Surface *""'"); 
  }
  arg1 = (Fl_Copy_Surface *)(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 '" "Fl_Copy_Surface_printable_rect" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (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 '" "Fl_Copy_Surface_printable_rect" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  {
    try {
      result = (int)(arg1)->printable_rect(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


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

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

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

SWIGINTERN PyObject *_wrap_Fl_Clock_Output_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock_Output *arg1 = (Fl_Clock_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Clock_Output *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Clock_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Clock_Output_draw" "', argument " "1"" of type '" "Fl_Clock_Output *""'"); 
  }
  arg1 = (Fl_Clock_Output *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Clock_Output *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Clock_Output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Clock_Output *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Clock_Output", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Clock_Output" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Clock_Output" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Clock_Output" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Clock_Output" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Clock_Output" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Clock_Output *)new SwigDirector_Fl_Clock_Output(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Clock_Output *)new Fl_Clock_Output(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Clock_Output, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Clock_Output_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Clock_Output *arg1 = (Fl_Clock_Output *) 0 ;
  ulong arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Clock_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Clock_Output_value" "', argument " "1"" of type '" "Fl_Clock_Output *""'"); 
  }
  arg1 = (Fl_Clock_Output *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Clock_Output_value" "', argument " "2"" of type '" "ulong""'");
  } 
  arg2 = (ulong)(val2);
  {
    try {
      (arg1)->value(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Clock_Output_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Clock_Output *arg1 = (Fl_Clock_Output *) 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_Fl_Clock_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Clock_Output_value" "', argument " "1"" of type '" "Fl_Clock_Output *""'"); 
  }
  arg1 = (Fl_Clock_Output *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Clock_Output_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Clock_Output_value" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Clock_Output_value" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      (arg1)->value(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Clock_Output_value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Clock_Output *arg1 = (Fl_Clock_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ulong result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Clock_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Clock_Output_value" "', argument " "1"" of type '" "Fl_Clock_Output const *""'"); 
  }
  arg1 = (Fl_Clock_Output *)(argp1);
  {
    try {
      result = (ulong)((Fl_Clock_Output const *)arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Clock_Output_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Clock_Output_value", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Clock_Output_value__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Clock_Output_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_Fl_Clock_Output_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Clock_Output_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Clock_Output::value(ulong)\n"
    "    Fl_Clock_Output::value(int,int,int)\n"
    "    Fl_Clock_Output::value() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Clock_Output_hour(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock_Output *arg1 = (Fl_Clock_Output *) 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_Fl_Clock_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Clock_Output_hour" "', argument " "1"" of type '" "Fl_Clock_Output const *""'"); 
  }
  arg1 = (Fl_Clock_Output *)(argp1);
  {
    try {
      result = (int)((Fl_Clock_Output const *)arg1)->hour(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Clock_Output_minute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock_Output *arg1 = (Fl_Clock_Output *) 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_Fl_Clock_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Clock_Output_minute" "', argument " "1"" of type '" "Fl_Clock_Output const *""'"); 
  }
  arg1 = (Fl_Clock_Output *)(argp1);
  {
    try {
      result = (int)((Fl_Clock_Output const *)arg1)->minute(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Clock_Output_second(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock_Output *arg1 = (Fl_Clock_Output *) 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_Fl_Clock_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Clock_Output_second" "', argument " "1"" of type '" "Fl_Clock_Output const *""'"); 
  }
  arg1 = (Fl_Clock_Output *)(argp1);
  {
    try {
      result = (int)((Fl_Clock_Output const *)arg1)->second(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Clock_Output_shadow__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Clock_Output *arg1 = (Fl_Clock_Output *) 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_Fl_Clock_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Clock_Output_shadow" "', argument " "1"" of type '" "Fl_Clock_Output const *""'"); 
  }
  arg1 = (Fl_Clock_Output *)(argp1);
  {
    try {
      result = (int)((Fl_Clock_Output const *)arg1)->shadow(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Clock_Output_shadow__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Clock_Output *arg1 = (Fl_Clock_Output *) 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_Fl_Clock_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Clock_Output_shadow" "', argument " "1"" of type '" "Fl_Clock_Output *""'"); 
  }
  arg1 = (Fl_Clock_Output *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Clock_Output_shadow" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->shadow(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Clock_Output_shadow(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Clock_Output_shadow", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Clock_Output_shadow__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Clock_Output_shadow__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Clock_Output_shadow'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Clock_Output::shadow() const\n"
    "    Fl_Clock_Output::shadow(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Clock_Output_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock_Output *arg1 = (Fl_Clock_Output *) 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, "Fl_Clock_Output_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Clock_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Clock_Output_init_type" "', argument " "1"" of type '" "Fl_Clock_Output *""'"); 
  }
  arg1 = (Fl_Clock_Output *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Clock_Output_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Clock_Output_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Clock_Output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock_Output *arg1 = (Fl_Clock_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Clock_Output, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Clock_Output" "', argument " "1"" of type '" "Fl_Clock_Output *""'"); 
  }
  arg1 = (Fl_Clock_Output *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Clock_Output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock_Output *arg1 = (Fl_Clock_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Clock_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Clock_Output" "', argument " "1"" of type '" "Fl_Clock_Output *""'"); 
  }
  arg1 = (Fl_Clock_Output *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Clock_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock *arg1 = (Fl_Clock *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Clock_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Clock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Clock_handle" "', argument " "1"" of type '" "Fl_Clock *""'"); 
  }
  arg1 = (Fl_Clock *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Clock_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Clock::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Clock__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  Fl_Clock *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Clock" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Clock" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Clock" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Clock" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Clock" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Clock *)new SwigDirector_Fl_Clock(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Clock *)new Fl_Clock(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Clock, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Clock__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  uchar arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  char *arg7 = (char *) 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int res7 ;
  char *buf7 = 0 ;
  int alloc7 = 0 ;
  Fl_Clock *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Clock" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Clock" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Clock" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Clock" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fl_Clock" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  res7 = SWIG_AsCharPtrAndSize(swig_obj[6], &buf7, NULL, &alloc7);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Fl_Clock" "', argument " "7"" of type '" "char const *""'");
  }
  arg7 = (char *)(buf7);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Clock *)new SwigDirector_Fl_Clock(arg1,arg2,arg3,arg4,arg5,arg6,(char const *)arg7); 
      } else {
        result = (Fl_Clock *)new Fl_Clock(arg2,arg3,arg4,arg5,arg6,(char const *)arg7); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Clock, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Clock(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_Clock", 0, 7, argv))) SWIG_fail;
  --argc;
  if ((argc >= 5) && (argc <= 6)) {
    PyObject *retobj = _wrap_new_Fl_Clock__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_new_Fl_Clock__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_Clock'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Clock::Fl_Clock(int,int,int,int,char const *)\n"
    "    Fl_Clock::Fl_Clock(PyObject *,uchar,int,int,int,int,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Clock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock *arg1 = (Fl_Clock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Clock, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Clock" "', argument " "1"" of type '" "Fl_Clock *""'"); 
  }
  arg1 = (Fl_Clock *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Clock_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock *arg1 = (Fl_Clock *) 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, "Fl_Clock_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Clock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Clock_init_type" "', argument " "1"" of type '" "Fl_Clock *""'"); 
  }
  arg1 = (Fl_Clock *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Clock_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Clock_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Clock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock *arg1 = (Fl_Clock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Clock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Clock" "', argument " "1"" of type '" "Fl_Clock *""'"); 
  }
  arg1 = (Fl_Clock *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Clock_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock *arg1 = (Fl_Clock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Clock *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Clock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Clock_draw" "', argument " "1"" of type '" "Fl_Clock *""'"); 
  }
  arg1 = (Fl_Clock *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Clock *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Value_Input_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Value_Input_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Input_handle" "', argument " "1"" of type '" "Fl_Value_Input *""'"); 
  }
  arg1 = (Fl_Value_Input *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Input_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Value_Input::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Value_Input *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Input_draw" "', argument " "1"" of type '" "Fl_Value_Input *""'"); 
  }
  arg1 = (Fl_Value_Input *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Value_Input *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Value_Input_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Input_resize" "', argument " "1"" of type '" "Fl_Value_Input *""'"); 
  }
  arg1 = (Fl_Value_Input *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Input_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Value_Input_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Value_Input_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Value_Input_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Value_Input::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Value_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Value_Input *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Value_Input", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Value_Input" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Value_Input" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Value_Input" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Value_Input" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Value_Input" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Value_Input *)new SwigDirector_Fl_Value_Input(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Value_Input *)new Fl_Value_Input(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Value_Input, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Value_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Input, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Value_Input" "', argument " "1"" of type '" "Fl_Value_Input *""'"); 
  }
  arg1 = (Fl_Value_Input *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_soft__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Input_soft" "', argument " "1"" of type '" "Fl_Value_Input *""'"); 
  }
  arg1 = (Fl_Value_Input *)(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Input_soft" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = (char)(val2);
  {
    try {
      (arg1)->soft(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_soft__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Input_soft" "', argument " "1"" of type '" "Fl_Value_Input const *""'"); 
  }
  arg1 = (Fl_Value_Input *)(argp1);
  {
    try {
      result = (char)((Fl_Value_Input const *)arg1)->soft(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new char(result)), SWIGTYPE_p_char, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_soft(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Value_Input_soft", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Value_Input_soft__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Value_Input_soft__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Value_Input_soft'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Value_Input::soft(char)\n"
    "    Fl_Value_Input::soft() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_shortcut__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 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_Fl_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Input_shortcut" "', argument " "1"" of type '" "Fl_Value_Input const *""'"); 
  }
  arg1 = (Fl_Value_Input *)(argp1);
  {
    try {
      result = (int)((Fl_Value_Input const *)arg1)->shortcut(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_shortcut__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 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_Fl_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Input_shortcut" "', argument " "1"" of type '" "Fl_Value_Input *""'"); 
  }
  arg1 = (Fl_Value_Input *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Input_shortcut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->shortcut(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_shortcut(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Value_Input_shortcut", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Value_Input_shortcut__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Value_Input_shortcut__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Value_Input_shortcut'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Value_Input::shortcut() const\n"
    "    Fl_Value_Input::shortcut(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_textfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Input_textfont" "', argument " "1"" of type '" "Fl_Value_Input const *""'"); 
  }
  arg1 = (Fl_Value_Input *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Value_Input const *)arg1)->textfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_textfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  Fl_Font 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_Fl_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Input_textfont" "', argument " "1"" of type '" "Fl_Value_Input *""'"); 
  }
  arg1 = (Fl_Value_Input *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Input_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->textfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_textfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Value_Input_textfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Value_Input_textfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Value_Input_textfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Value_Input_textfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Value_Input::textfont() const\n"
    "    Fl_Value_Input::textfont(Fl_Font)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_textsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Input_textsize" "', argument " "1"" of type '" "Fl_Value_Input const *""'"); 
  }
  arg1 = (Fl_Value_Input *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Value_Input const *)arg1)->textsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_textsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  Fl_Fontsize 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_Fl_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Input_textsize" "', argument " "1"" of type '" "Fl_Value_Input *""'"); 
  }
  arg1 = (Fl_Value_Input *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Input_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->textsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_textsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Value_Input_textsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Value_Input_textsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Value_Input_textsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Value_Input_textsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Value_Input::textsize() const\n"
    "    Fl_Value_Input::textsize(Fl_Fontsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_textcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Input_textcolor" "', argument " "1"" of type '" "Fl_Value_Input const *""'"); 
  }
  arg1 = (Fl_Value_Input *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Value_Input const *)arg1)->textcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_textcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Input_textcolor" "', argument " "1"" of type '" "Fl_Value_Input *""'"); 
  }
  arg1 = (Fl_Value_Input *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Input_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->textcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_textcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Value_Input_textcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Value_Input_textcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Value_Input_textcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Value_Input_textcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Value_Input::textcolor() const\n"
    "    Fl_Value_Input::textcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_cursor_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Input_cursor_color" "', argument " "1"" of type '" "Fl_Value_Input const *""'"); 
  }
  arg1 = (Fl_Value_Input *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Value_Input const *)arg1)->cursor_color(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_cursor_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Input_cursor_color" "', argument " "1"" of type '" "Fl_Value_Input *""'"); 
  }
  arg1 = (Fl_Value_Input *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Input_cursor_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->cursor_color(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_cursor_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Value_Input_cursor_color", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Value_Input_cursor_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Value_Input_cursor_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Value_Input_cursor_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Value_Input::cursor_color() const\n"
    "    Fl_Value_Input::cursor_color(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 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, "Fl_Value_Input_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Input_init_type" "', argument " "1"" of type '" "Fl_Value_Input *""'"); 
  }
  arg1 = (Fl_Value_Input *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Value_Input_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Value_Input_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Value_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Value_Input" "', argument " "1"" of type '" "Fl_Value_Input *""'"); 
  }
  arg1 = (Fl_Value_Input *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Flcc_HueBox_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_HueBox *arg1 = (Flcc_HueBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Flcc_HueBox *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Flcc_HueBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Flcc_HueBox_draw" "', argument " "1"" of type '" "Flcc_HueBox *""'"); 
  }
  arg1 = (Flcc_HueBox *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Flcc_HueBox *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Flcc_HueBox_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_HueBox *arg1 = (Flcc_HueBox *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Flcc_HueBox_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Flcc_HueBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Flcc_HueBox_handle" "', argument " "1"" of type '" "Flcc_HueBox *""'"); 
  }
  arg1 = (Flcc_HueBox *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Flcc_HueBox_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Flcc_HueBox::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Flcc_HueBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Flcc_HueBox *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Flcc_HueBox", 5, 5, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Flcc_HueBox" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Flcc_HueBox" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Flcc_HueBox" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Flcc_HueBox" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Flcc_HueBox *)new SwigDirector_Flcc_HueBox(arg1,arg2,arg3,arg4,arg5); 
      } else {
        result = (Flcc_HueBox *)new Flcc_HueBox(arg2,arg3,arg4,arg5); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Flcc_HueBox, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Flcc_HueBox_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_HueBox *arg1 = (Flcc_HueBox *) 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, "Flcc_HueBox_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Flcc_HueBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Flcc_HueBox_init_type" "', argument " "1"" of type '" "Flcc_HueBox *""'"); 
  }
  arg1 = (Flcc_HueBox *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Flcc_HueBox_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Flcc_HueBox_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Flcc_HueBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_HueBox *arg1 = (Flcc_HueBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Flcc_HueBox, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Flcc_HueBox" "', argument " "1"" of type '" "Flcc_HueBox *""'"); 
  }
  arg1 = (Flcc_HueBox *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Flcc_HueBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_HueBox *arg1 = (Flcc_HueBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Flcc_HueBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Flcc_HueBox" "', argument " "1"" of type '" "Flcc_HueBox *""'"); 
  }
  arg1 = (Flcc_HueBox *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Flcc_ValueBox_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_ValueBox *arg1 = (Flcc_ValueBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Flcc_ValueBox *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Flcc_ValueBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Flcc_ValueBox_draw" "', argument " "1"" of type '" "Flcc_ValueBox *""'"); 
  }
  arg1 = (Flcc_ValueBox *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Flcc_ValueBox *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Flcc_ValueBox_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_ValueBox *arg1 = (Flcc_ValueBox *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Flcc_ValueBox_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Flcc_ValueBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Flcc_ValueBox_handle" "', argument " "1"" of type '" "Flcc_ValueBox *""'"); 
  }
  arg1 = (Flcc_ValueBox *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Flcc_ValueBox_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Flcc_ValueBox::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Flcc_ValueBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Flcc_ValueBox *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Flcc_ValueBox", 5, 5, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Flcc_ValueBox" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Flcc_ValueBox" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Flcc_ValueBox" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Flcc_ValueBox" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Flcc_ValueBox *)new SwigDirector_Flcc_ValueBox(arg1,arg2,arg3,arg4,arg5); 
      } else {
        result = (Flcc_ValueBox *)new Flcc_ValueBox(arg2,arg3,arg4,arg5); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Flcc_ValueBox, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Flcc_ValueBox_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_ValueBox *arg1 = (Flcc_ValueBox *) 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, "Flcc_ValueBox_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Flcc_ValueBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Flcc_ValueBox_init_type" "', argument " "1"" of type '" "Flcc_ValueBox *""'"); 
  }
  arg1 = (Flcc_ValueBox *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Flcc_ValueBox_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Flcc_ValueBox_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Flcc_ValueBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_ValueBox *arg1 = (Flcc_ValueBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Flcc_ValueBox, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Flcc_ValueBox" "', argument " "1"" of type '" "Flcc_ValueBox *""'"); 
  }
  arg1 = (Flcc_ValueBox *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Flcc_ValueBox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_ValueBox *arg1 = (Flcc_ValueBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Flcc_ValueBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Flcc_ValueBox" "', argument " "1"" of type '" "Flcc_ValueBox *""'"); 
  }
  arg1 = (Flcc_ValueBox *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Flcc_Value_Input_format(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_Value_Input *arg1 = (Flcc_Value_Input *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Flcc_Value_Input_format", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Flcc_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Flcc_Value_Input_format" "', argument " "1"" of type '" "Flcc_Value_Input *""'"); 
  }
  arg1 = (Flcc_Value_Input *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Flcc_Value_Input_format" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Flcc_Value_Input::format(arg2);
        } else {
          result = (int)(arg1)->format(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Flcc_Value_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Flcc_Value_Input *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Flcc_Value_Input", 5, 5, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Flcc_Value_Input" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Flcc_Value_Input" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Flcc_Value_Input" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Flcc_Value_Input" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Flcc_Value_Input *)new SwigDirector_Flcc_Value_Input(arg1,arg2,arg3,arg4,arg5); 
      } else {
        result = (Flcc_Value_Input *)new Flcc_Value_Input(arg2,arg3,arg4,arg5); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Flcc_Value_Input, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Flcc_Value_Input_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_Value_Input *arg1 = (Flcc_Value_Input *) 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, "Flcc_Value_Input_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Flcc_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Flcc_Value_Input_init_type" "', argument " "1"" of type '" "Flcc_Value_Input *""'"); 
  }
  arg1 = (Flcc_Value_Input *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Flcc_Value_Input_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Flcc_Value_Input_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Flcc_Value_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_Value_Input *arg1 = (Flcc_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Flcc_Value_Input, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Flcc_Value_Input" "', argument " "1"" of type '" "Flcc_Value_Input *""'"); 
  }
  arg1 = (Flcc_Value_Input *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Flcc_Value_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_Value_Input *arg1 = (Flcc_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Flcc_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Flcc_Value_Input" "', argument " "1"" of type '" "Flcc_Value_Input *""'"); 
  }
  arg1 = (Flcc_Value_Input *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Flcc_Value_Input_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_Value_Input *arg1 = (Flcc_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Flcc_Value_Input *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Flcc_Value_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Flcc_Value_Input_draw" "', argument " "1"" of type '" "Flcc_Value_Input *""'"); 
  }
  arg1 = (Flcc_Value_Input *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Flcc_Value_Input *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Color_Chooser_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Color_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Color_Chooser_handle" "', argument " "1"" of type '" "Fl_Color_Chooser *""'"); 
  }
  arg1 = (Fl_Color_Chooser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Color_Chooser_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Color_Chooser::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_mode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 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_Fl_Color_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Color_Chooser_mode" "', argument " "1"" of type '" "Fl_Color_Chooser *""'"); 
  }
  arg1 = (Fl_Color_Chooser *)(argp1);
  {
    try {
      result = (int)(arg1)->mode(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_mode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 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_Fl_Color_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Color_Chooser_mode" "', argument " "1"" of type '" "Fl_Color_Chooser *""'"); 
  }
  arg1 = (Fl_Color_Chooser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Color_Chooser_mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->mode(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_mode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Color_Chooser_mode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Color_Chooser_mode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Color_Chooser_mode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Color_Chooser_mode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Color_Chooser::mode()\n"
    "    Fl_Color_Chooser::mode(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_hue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 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_Fl_Color_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Color_Chooser_hue" "', argument " "1"" of type '" "Fl_Color_Chooser const *""'"); 
  }
  arg1 = (Fl_Color_Chooser *)(argp1);
  {
    try {
      result = (double)((Fl_Color_Chooser const *)arg1)->hue(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_saturation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 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_Fl_Color_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Color_Chooser_saturation" "', argument " "1"" of type '" "Fl_Color_Chooser const *""'"); 
  }
  arg1 = (Fl_Color_Chooser *)(argp1);
  {
    try {
      result = (double)((Fl_Color_Chooser const *)arg1)->saturation(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 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_Fl_Color_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Color_Chooser_value" "', argument " "1"" of type '" "Fl_Color_Chooser const *""'"); 
  }
  arg1 = (Fl_Color_Chooser *)(argp1);
  {
    try {
      result = (double)((Fl_Color_Chooser const *)arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_r(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 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_Fl_Color_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Color_Chooser_r" "', argument " "1"" of type '" "Fl_Color_Chooser const *""'"); 
  }
  arg1 = (Fl_Color_Chooser *)(argp1);
  {
    try {
      result = (double)((Fl_Color_Chooser const *)arg1)->r(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_g(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 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_Fl_Color_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Color_Chooser_g" "', argument " "1"" of type '" "Fl_Color_Chooser const *""'"); 
  }
  arg1 = (Fl_Color_Chooser *)(argp1);
  {
    try {
      result = (double)((Fl_Color_Chooser const *)arg1)->g(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_b(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 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_Fl_Color_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Color_Chooser_b" "', argument " "1"" of type '" "Fl_Color_Chooser const *""'"); 
  }
  arg1 = (Fl_Color_Chooser *)(argp1);
  {
    try {
      result = (double)((Fl_Color_Chooser const *)arg1)->b(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_hsv(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Color_Chooser_hsv", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Color_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Color_Chooser_hsv" "', argument " "1"" of type '" "Fl_Color_Chooser *""'"); 
  }
  arg1 = (Fl_Color_Chooser *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Color_Chooser_hsv" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Color_Chooser_hsv" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Color_Chooser_hsv" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  {
    try {
      result = (int)(arg1)->hsv(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_rgb(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Color_Chooser_rgb", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Color_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Color_Chooser_rgb" "', argument " "1"" of type '" "Fl_Color_Chooser *""'"); 
  }
  arg1 = (Fl_Color_Chooser *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Color_Chooser_rgb" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Color_Chooser_rgb" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Color_Chooser_rgb" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  {
    try {
      result = (int)(arg1)->rgb(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_hsv2rgb(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Color_Chooser_hsv2rgb", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Color_Chooser_hsv2rgb" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Color_Chooser_hsv2rgb" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Color_Chooser_hsv2rgb" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Color_Chooser_hsv2rgb" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Color_Chooser_hsv2rgb" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Fl_Color_Chooser_hsv2rgb" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Color_Chooser_hsv2rgb" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Fl_Color_Chooser_hsv2rgb" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Color_Chooser_hsv2rgb" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = (double *)(argp6);
  {
    try {
      Fl_Color_Chooser::hsv2rgb(arg1,arg2,arg3,*arg4,*arg5,*arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_rgb2hsv(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Color_Chooser_rgb2hsv", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Color_Chooser_rgb2hsv" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Color_Chooser_rgb2hsv" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Color_Chooser_rgb2hsv" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Color_Chooser_rgb2hsv" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Color_Chooser_rgb2hsv" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = (double *)(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Fl_Color_Chooser_rgb2hsv" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Color_Chooser_rgb2hsv" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = (double *)(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Fl_Color_Chooser_rgb2hsv" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Color_Chooser_rgb2hsv" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = (double *)(argp6);
  {
    try {
      Fl_Color_Chooser::rgb2hsv(arg1,arg2,arg3,*arg4,*arg5,*arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Color_Chooser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Color_Chooser *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Color_Chooser", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Color_Chooser" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Color_Chooser" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Color_Chooser" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Color_Chooser" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Color_Chooser" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Color_Chooser *)new SwigDirector_Fl_Color_Chooser(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Color_Chooser *)new Fl_Color_Chooser(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Color_Chooser, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 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, "Fl_Color_Chooser_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Color_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Color_Chooser_init_type" "', argument " "1"" of type '" "Fl_Color_Chooser *""'"); 
  }
  arg1 = (Fl_Color_Chooser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Color_Chooser_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Color_Chooser_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Color_Chooser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Color_Chooser, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Color_Chooser" "', argument " "1"" of type '" "Fl_Color_Chooser *""'"); 
  }
  arg1 = (Fl_Color_Chooser *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Color_Chooser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Color_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Color_Chooser" "', argument " "1"" of type '" "Fl_Color_Chooser *""'"); 
  }
  arg1 = (Fl_Color_Chooser *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Color_Chooser *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Color_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Color_Chooser_draw" "', argument " "1"" of type '" "Fl_Color_Chooser *""'"); 
  }
  arg1 = (Fl_Color_Chooser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Color_Chooser *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_fl_color_chooser__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  int arg5 = (int) -1 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_color_chooser" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_color_chooser" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_color_chooser" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = (double *)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_color_chooser" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_color_chooser" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = (double *)(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "fl_color_chooser" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_color_chooser" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = (double *)(argp4);
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_color_chooser" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = (int)(val5);
  }
  {
    try {
      result = (int)fl_color_chooser((char const *)arg1,*arg2,*arg3,*arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_color_chooser__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  uchar *arg2 = 0 ;
  uchar *arg3 = 0 ;
  uchar *arg4 = 0 ;
  int arg5 = (int) -1 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  uchar temp2 ;
  int res2 = 0 ;
  uchar temp3 ;
  int res3 = 0 ;
  uchar temp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_color_chooser" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_unsigned_char,0))))) {
    unsigned char val;
    int ecode = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val);
    if (!SWIG_IsOK(ecode)) {
      SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "fl_color_chooser" "', argument " "2"" of type '" "uchar""'");
    }
    temp2 = (uchar)(val);
    arg2 = &temp2;
    res2 = SWIG_AddTmpMask(ecode);
  }
  if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_unsigned_char,0))))) {
    unsigned char val;
    int ecode = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val);
    if (!SWIG_IsOK(ecode)) {
      SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "fl_color_chooser" "', argument " "3"" of type '" "uchar""'");
    }
    temp3 = (uchar)(val);
    arg3 = &temp3;
    res3 = SWIG_AddTmpMask(ecode);
  }
  if (!(SWIG_IsOK((res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4),SWIGTYPE_p_unsigned_char,0))))) {
    unsigned char val;
    int ecode = SWIG_AsVal_unsigned_SS_char(swig_obj[3], &val);
    if (!SWIG_IsOK(ecode)) {
      SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "fl_color_chooser" "', argument " "4"" of type '" "uchar""'");
    }
    temp4 = (uchar)(val);
    arg4 = &temp4;
    res4 = SWIG_AddTmpMask(ecode);
  }
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_color_chooser" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = (int)(val5);
  }
  {
    try {
      result = (int)fl_color_chooser((char const *)arg1,*arg2,*arg3,*arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags), 0);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_color_chooser(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_color_chooser", 0, 5, argv))) SWIG_fail;
  --argc;
  if ((argc >= 4) && (argc <= 5)) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_fl_color_chooser__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if ((argc >= 4) && (argc <= 5)) {
    PyObject *retobj = _wrap_fl_color_chooser__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_color_chooser'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_color_chooser(char const *,double &,double &,double &,int)\n"
    "    fl_color_chooser(char const *,uchar &,uchar &,uchar &,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Counter *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Counter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Counter_draw" "', argument " "1"" of type '" "Fl_Counter *""'"); 
  }
  arg1 = (Fl_Counter *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Counter *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Counter_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Counter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Counter_handle" "', argument " "1"" of type '" "Fl_Counter *""'"); 
  }
  arg1 = (Fl_Counter *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Counter_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Counter::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Counter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Counter *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Counter", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Counter" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Counter" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Counter" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Counter" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Counter" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Counter *)new SwigDirector_Fl_Counter(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Counter *)new Fl_Counter(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Counter, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Counter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Counter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Counter" "', argument " "1"" of type '" "Fl_Counter *""'"); 
  }
  arg1 = (Fl_Counter *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_lstep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 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, "Fl_Counter_lstep", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Counter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Counter_lstep" "', argument " "1"" of type '" "Fl_Counter *""'"); 
  }
  arg1 = (Fl_Counter *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Counter_lstep" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      (arg1)->lstep(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_step__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Counter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Counter_step" "', argument " "1"" of type '" "Fl_Counter *""'"); 
  }
  arg1 = (Fl_Counter *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Counter_step" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Counter_step" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  {
    try {
      (arg1)->step(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_step__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 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_Fl_Counter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Counter_step" "', argument " "1"" of type '" "Fl_Counter *""'"); 
  }
  arg1 = (Fl_Counter *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Counter_step" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      (arg1)->step(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_step__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 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_Fl_Counter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Counter_step" "', argument " "1"" of type '" "Fl_Counter const *""'"); 
  }
  arg1 = (Fl_Counter *)(argp1);
  {
    try {
      result = (double)((Fl_Counter const *)arg1)->step(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_step(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Counter_step", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Counter_step__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Counter_step__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Counter_step__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Counter_step'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Counter::step(double,double)\n"
    "    Fl_Counter::step(double)\n"
    "    Fl_Counter::step() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_textfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Counter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Counter_textfont" "', argument " "1"" of type '" "Fl_Counter const *""'"); 
  }
  arg1 = (Fl_Counter *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Counter const *)arg1)->textfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_textfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  Fl_Font 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_Fl_Counter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Counter_textfont" "', argument " "1"" of type '" "Fl_Counter *""'"); 
  }
  arg1 = (Fl_Counter *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Counter_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->textfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_textfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Counter_textfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Counter_textfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Counter_textfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Counter_textfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Counter::textfont() const\n"
    "    Fl_Counter::textfont(Fl_Font)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_textsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Counter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Counter_textsize" "', argument " "1"" of type '" "Fl_Counter const *""'"); 
  }
  arg1 = (Fl_Counter *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Counter const *)arg1)->textsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_textsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  Fl_Fontsize 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_Fl_Counter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Counter_textsize" "', argument " "1"" of type '" "Fl_Counter *""'"); 
  }
  arg1 = (Fl_Counter *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Counter_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->textsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_textsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Counter_textsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Counter_textsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Counter_textsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Counter_textsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Counter::textsize() const\n"
    "    Fl_Counter::textsize(Fl_Fontsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_textcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Counter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Counter_textcolor" "', argument " "1"" of type '" "Fl_Counter const *""'"); 
  }
  arg1 = (Fl_Counter *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Counter const *)arg1)->textcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_textcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Counter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Counter_textcolor" "', argument " "1"" of type '" "Fl_Counter *""'"); 
  }
  arg1 = (Fl_Counter *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Counter_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->textcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_textcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Counter_textcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Counter_textcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Counter_textcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Counter_textcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Counter::textcolor() const\n"
    "    Fl_Counter::textcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 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, "Fl_Counter_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Counter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Counter_init_type" "', argument " "1"" of type '" "Fl_Counter *""'"); 
  }
  arg1 = (Fl_Counter *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Counter_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Counter_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Counter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Counter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Counter" "', argument " "1"" of type '" "Fl_Counter *""'"); 
  }
  arg1 = (Fl_Counter *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Plugin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  Fl_Plugin *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Plugin", 3, 3, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_Plugin" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fl_Plugin" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Plugin *)new SwigDirector_Fl_Plugin(arg1,(char const *)arg2,(char const *)arg3); 
      } else {
        result = (Fl_Plugin *)new Fl_Plugin((char const *)arg2,(char const *)arg3); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Plugin, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Plugin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Plugin *arg1 = (Fl_Plugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Plugin, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Plugin" "', argument " "1"" of type '" "Fl_Plugin *""'"); 
  }
  arg1 = (Fl_Plugin *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Plugin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Plugin *arg1 = (Fl_Plugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Plugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Plugin" "', argument " "1"" of type '" "Fl_Plugin *""'"); 
  }
  arg1 = (Fl_Plugin *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Plugin_Manager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Plugin_Manager *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 '" "new_Fl_Plugin_Manager" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (Fl_Plugin_Manager *)new Fl_Plugin_Manager((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Plugin_Manager, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Plugin_Manager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Plugin_Manager *arg1 = (Fl_Plugin_Manager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Plugin_Manager, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Plugin_Manager" "', argument " "1"" of type '" "Fl_Plugin_Manager *""'"); 
  }
  arg1 = (Fl_Plugin_Manager *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Plugin_Manager_plugins(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Plugin_Manager *arg1 = (Fl_Plugin_Manager *) 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_Fl_Plugin_Manager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Plugin_Manager_plugins" "', argument " "1"" of type '" "Fl_Plugin_Manager *""'"); 
  }
  arg1 = (Fl_Plugin_Manager *)(argp1);
  {
    try {
      result = (int)(arg1)->plugins(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Plugin_Manager_plugin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Plugin_Manager *arg1 = (Fl_Plugin_Manager *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Swig::Director *director = 0;
  Fl_Plugin *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Plugin_Manager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Plugin_Manager_plugin" "', argument " "1"" of type '" "Fl_Plugin_Manager *""'"); 
  }
  arg1 = (Fl_Plugin_Manager *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Plugin_Manager_plugin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (Fl_Plugin *)(arg1)->plugin(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Plugin, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Plugin_Manager_plugin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Plugin_Manager *arg1 = (Fl_Plugin_Manager *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  Swig::Director *director = 0;
  Fl_Plugin *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Plugin_Manager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Plugin_Manager_plugin" "', argument " "1"" of type '" "Fl_Plugin_Manager *""'"); 
  }
  arg1 = (Fl_Plugin_Manager *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Plugin_Manager_plugin" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (Fl_Plugin *)(arg1)->plugin((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Plugin, 0 |  0 );
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Plugin_Manager_plugin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Plugin_Manager_plugin", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Plugin_Manager_plugin__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Plugin_Manager_plugin__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Plugin_Manager_plugin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Plugin_Manager::plugin(int)\n"
    "    Fl_Plugin_Manager::plugin(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Plugin_Manager_addPlugin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Plugin_Manager *arg1 = (Fl_Plugin_Manager *) 0 ;
  char *arg2 = (char *) 0 ;
  Fl_Plugin *arg3 = (Fl_Plugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  Fl_Preferences::ID result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Plugin_Manager_addPlugin", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Plugin_Manager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Plugin_Manager_addPlugin" "', argument " "1"" of type '" "Fl_Plugin_Manager *""'"); 
  }
  arg1 = (Fl_Plugin_Manager *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Plugin_Manager_addPlugin" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Fl_Plugin, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Plugin_Manager_addPlugin" "', argument " "3"" of type '" "Fl_Plugin *""'"); 
  }
  arg3 = (Fl_Plugin *)(argp3);
  {
    try {
      result = (arg1)->addPlugin((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new Fl_Preferences::ID(result)), SWIGTYPE_p_Fl_Preferences__ID, SWIG_POINTER_OWN |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Plugin_Manager_removePlugin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Preferences::ID arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Preferences__ID,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Plugin_Manager_removePlugin" "', argument " "1"" of type '" "Fl_Preferences::ID""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Plugin_Manager_removePlugin" "', argument " "1"" of type '" "Fl_Preferences::ID""'");
    } else {
      Fl_Preferences::ID * temp = (Fl_Preferences::ID *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      Fl_Plugin_Manager::removePlugin(SWIG_STD_MOVE(arg1)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Plugin_Manager_load(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Plugin_Manager_load" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (int)Fl_Plugin_Manager::load((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Plugin_Manager_loadAll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Plugin_Manager_loadAll", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Plugin_Manager_loadAll" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  if (swig_obj[1]) {
    res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Plugin_Manager_loadAll" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = (char *)(buf2);
  }
  {
    try {
      result = (int)Fl_Plugin_Manager::loadAll((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Surface_Device_end_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Surface_Device *arg1 = (Fl_Surface_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Surface_Device *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Surface_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Surface_Device_end_current" "', argument " "1"" of type '" "Fl_Surface_Device *""'"); 
  }
  arg1 = (Fl_Surface_Device *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("end_current"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member end_current");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Surface_Device *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->end_currentSwigPublic();
        } else {
          (darg)->end_current();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Surface_Device(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  Fl_Graphics_Driver *arg2 = (Fl_Graphics_Driver *) 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Fl_Surface_Device *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Surface_Device", 2, 2, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Graphics_Driver, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_Surface_Device" "', argument " "2"" of type '" "Fl_Graphics_Driver *""'"); 
  }
  arg2 = (Fl_Graphics_Driver *)(argp2);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Surface_Device *)new SwigDirector_Fl_Surface_Device(arg1,arg2); 
      } else {
        SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
        SWIG_fail;
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Surface_Device, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Surface_Device_set_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Surface_Device *arg1 = (Fl_Surface_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Surface_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Surface_Device_set_current" "', argument " "1"" of type '" "Fl_Surface_Device *""'"); 
  }
  arg1 = (Fl_Surface_Device *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Surface_Device::set_current();
        } else {
          (arg1)->set_current();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Surface_Device_is_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Surface_Device *arg1 = (Fl_Surface_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Surface_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Surface_Device_is_current" "', argument " "1"" of type '" "Fl_Surface_Device *""'"); 
  }
  arg1 = (Fl_Surface_Device *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (bool)(arg1)->Fl_Surface_Device::is_current();
        } else {
          result = (bool)(arg1)->is_current();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Surface_Device_driver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Surface_Device *arg1 = (Fl_Surface_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Graphics_Driver *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Surface_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Surface_Device_driver" "', argument " "1"" of type '" "Fl_Surface_Device *""'"); 
  }
  arg1 = (Fl_Surface_Device *)(argp1);
  {
    try {
      result = (Fl_Graphics_Driver *)(arg1)->driver(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Graphics_Driver, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Surface_Device_surface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swig::Director *director = 0;
  Fl_Surface_Device *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Surface_Device_surface", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Surface_Device *)Fl_Surface_Device::surface(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Surface_Device, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Surface_Device(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Surface_Device *arg1 = (Fl_Surface_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Surface_Device, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Surface_Device" "', argument " "1"" of type '" "Fl_Surface_Device *""'"); 
  }
  arg1 = (Fl_Surface_Device *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Surface_Device_push_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Surface_Device *arg1 = (Fl_Surface_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Surface_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Surface_Device_push_current" "', argument " "1"" of type '" "Fl_Surface_Device *""'"); 
  }
  arg1 = (Fl_Surface_Device *)(argp1);
  {
    try {
      Fl_Surface_Device::push_current(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Surface_Device_pop_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swig::Director *director = 0;
  Fl_Surface_Device *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Surface_Device_pop_current", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Surface_Device *)Fl_Surface_Device::pop_current(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Surface_Device, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Surface_Device(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Surface_Device *arg1 = (Fl_Surface_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Surface_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Surface_Device" "', argument " "1"" of type '" "Fl_Surface_Device *""'"); 
  }
  arg1 = (Fl_Surface_Device *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Display_Device_display_device(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swig::Director *director = 0;
  Fl_Display_Device *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Display_Device_display_device", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Display_Device *)Fl_Display_Device::display_device(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Display_Device, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Display_Device(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Display_Device *arg1 = (Fl_Display_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Display_Device, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Display_Device" "', argument " "1"" of type '" "Fl_Display_Device *""'"); 
  }
  arg1 = (Fl_Display_Device *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Display_Device(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Display_Device *arg1 = (Fl_Display_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Display_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Display_Device" "', argument " "1"" of type '" "Fl_Display_Device *""'"); 
  }
  arg1 = (Fl_Display_Device *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Display_Device_end_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Display_Device *arg1 = (Fl_Display_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Display_Device *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Display_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Display_Device_end_current" "', argument " "1"" of type '" "Fl_Display_Device *""'"); 
  }
  arg1 = (Fl_Display_Device *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("end_current"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member end_current");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Display_Device *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->end_currentSwigPublic();
        } else {
          (darg)->end_current();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Fl_Device_Plugin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Fl_Device_Plugin *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Device_Plugin", 2, 2, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_Device_Plugin" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Device_Plugin *)new SwigDirector_Fl_Device_Plugin(arg1,(char const *)arg2); 
      } else {
        SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
        SWIG_fail;
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Device_Plugin, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Device_Plugin_klass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Device_Plugin *arg1 = (Fl_Device_Plugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Device_Plugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Device_Plugin_klass" "', argument " "1"" of type '" "Fl_Device_Plugin *""'"); 
  }
  arg1 = (Fl_Device_Plugin *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (char *)(arg1)->Fl_Device_Plugin::klass();
        } else {
          result = (char *)(arg1)->klass();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (director) {
    director->swig_release_ownership(SWIG_as_voidptr(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Device_Plugin_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Device_Plugin *arg1 = (Fl_Device_Plugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Device_Plugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Device_Plugin_name" "', argument " "1"" of type '" "Fl_Device_Plugin *""'"); 
  }
  arg1 = (Fl_Device_Plugin *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Fl_Device_Plugin::name");
        } else {
          result = (char *)(arg1)->name();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (director) {
    director->swig_release_ownership(SWIG_as_voidptr(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Device_Plugin__print(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Device_Plugin *arg1 = (Fl_Device_Plugin *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Device_Plugin__print", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Device_Plugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Device_Plugin__print" "', argument " "1"" of type '" "Fl_Device_Plugin *""'"); 
  }
  arg1 = (Fl_Device_Plugin *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Device_Plugin__print" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Fl_Device_Plugin::print");
        } else {
          result = (int)(arg1)->print(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Device_Plugin_rectangle_capture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Device_Plugin *arg1 = (Fl_Device_Plugin *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_RGB_Image *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Device_Plugin_rectangle_capture", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Device_Plugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Device_Plugin_rectangle_capture" "', argument " "1"" of type '" "Fl_Device_Plugin *""'"); 
  }
  arg1 = (Fl_Device_Plugin *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Device_Plugin_rectangle_capture" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Device_Plugin_rectangle_capture" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Device_Plugin_rectangle_capture" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Device_Plugin_rectangle_capture" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Device_Plugin_rectangle_capture" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Fl_Device_Plugin::rectangle_capture");
        } else {
          result = (Fl_RGB_Image *)(arg1)->rectangle_capture(arg2,arg3,arg4,arg5,arg6);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Device_Plugin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Device_Plugin *arg1 = (Fl_Device_Plugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Device_Plugin, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Device_Plugin" "', argument " "1"" of type '" "Fl_Device_Plugin *""'"); 
  }
  arg1 = (Fl_Device_Plugin *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Device_Plugin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Device_Plugin *arg1 = (Fl_Device_Plugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Device_Plugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Device_Plugin" "', argument " "1"" of type '" "Fl_Device_Plugin *""'"); 
  }
  arg1 = (Fl_Device_Plugin *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Dial_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Dial *arg1 = (Fl_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Dial *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Dial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Dial_draw" "', argument " "1"" of type '" "Fl_Dial *""'"); 
  }
  arg1 = (Fl_Dial *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Dial *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Dial_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Dial *arg1 = (Fl_Dial *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Dial_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Dial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Dial_handle" "', argument " "1"" of type '" "Fl_Dial *""'"); 
  }
  arg1 = (Fl_Dial *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Dial_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Dial::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Dial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Dial *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Dial", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Dial" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Dial" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Dial" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Dial" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Dial" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Dial *)new SwigDirector_Fl_Dial(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Dial *)new Fl_Dial(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Dial, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Dial_angle1__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Dial *arg1 = (Fl_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Dial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Dial_angle1" "', argument " "1"" of type '" "Fl_Dial const *""'"); 
  }
  arg1 = (Fl_Dial *)(argp1);
  {
    try {
      result = (short)((Fl_Dial const *)arg1)->angle1(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Dial_angle1__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Dial *arg1 = (Fl_Dial *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Dial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Dial_angle1" "', argument " "1"" of type '" "Fl_Dial *""'"); 
  }
  arg1 = (Fl_Dial *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Dial_angle1" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = (short)(val2);
  {
    try {
      (arg1)->angle1(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Dial_angle1(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Dial_angle1", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Dial_angle1__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Dial_angle1__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Dial_angle1'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Dial::angle1() const\n"
    "    Fl_Dial::angle1(short)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Dial_angle2__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Dial *arg1 = (Fl_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Dial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Dial_angle2" "', argument " "1"" of type '" "Fl_Dial const *""'"); 
  }
  arg1 = (Fl_Dial *)(argp1);
  {
    try {
      result = (short)((Fl_Dial const *)arg1)->angle2(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Dial_angle2__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Dial *arg1 = (Fl_Dial *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Dial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Dial_angle2" "', argument " "1"" of type '" "Fl_Dial *""'"); 
  }
  arg1 = (Fl_Dial *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Dial_angle2" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = (short)(val2);
  {
    try {
      (arg1)->angle2(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Dial_angle2(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Dial_angle2", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Dial_angle2__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Dial_angle2__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Dial_angle2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Dial::angle2() const\n"
    "    Fl_Dial::angle2(short)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Dial_angles(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Dial *arg1 = (Fl_Dial *) 0 ;
  short arg2 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Dial_angles", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Dial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Dial_angles" "', argument " "1"" of type '" "Fl_Dial *""'"); 
  }
  arg1 = (Fl_Dial *)(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Dial_angles" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = (short)(val2);
  ecode3 = SWIG_AsVal_short(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Dial_angles" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = (short)(val3);
  {
    try {
      (arg1)->angles(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Dial_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Dial *arg1 = (Fl_Dial *) 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, "Fl_Dial_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Dial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Dial_init_type" "', argument " "1"" of type '" "Fl_Dial *""'"); 
  }
  arg1 = (Fl_Dial *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Dial_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Dial_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Dial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Dial *arg1 = (Fl_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Dial, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Dial" "', argument " "1"" of type '" "Fl_Dial *""'"); 
  }
  arg1 = (Fl_Dial *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Dial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Dial *arg1 = (Fl_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Dial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Dial" "', argument " "1"" of type '" "Fl_Dial *""'"); 
  }
  arg1 = (Fl_Dial *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Window_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Window *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_draw" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Window *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_flush(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_flush" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Window::flush();
        } else {
          (arg1)->flush();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Window__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  char *arg4 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  Fl_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  if (swig_obj[3]) {
    res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Fl_Window" "', argument " "4"" of type '" "char const *""'");
    }
    arg4 = (char *)(buf4);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Window *)new SwigDirector_Fl_Window(arg1,arg2,arg3,(char const *)arg4); 
      } else {
        result = (Fl_Window *)new Fl_Window(arg2,arg3,(char const *)arg4); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Window__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  Fl_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Window" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Window" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Window" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Window *)new SwigDirector_Fl_Window(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Window *)new Fl_Window(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Window(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_Window", 0, 6, argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    PyObject *retobj = _wrap_new_Fl_Window__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 5) && (argc <= 6)) {
    PyObject *retobj = _wrap_new_Fl_Window__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_Window'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Window::Fl_Window(int,int,char const *)\n"
    "    Fl_Window::Fl_Window(PyObject *,int,int,int,int,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Window" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Window_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_handle" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Window::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Window_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_resize" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Window_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Window_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Window::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_border__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 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_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_border" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_border" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->border(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_clear_border(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_clear_border" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      (arg1)->clear_border(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_border__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_border" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (unsigned int)((Fl_Window const *)arg1)->border(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_border(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Window_border", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Window_border__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Window_border__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Window_border'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Window::border(int)\n"
    "    Fl_Window::border() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Window_set_override(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_set_override" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      (arg1)->set_override(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_override(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_override" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (unsigned int)((Fl_Window const *)arg1)->override(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_set_modal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_set_modal" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      (arg1)->set_modal(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_modal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_modal" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (unsigned int)((Fl_Window const *)arg1)->modal(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_set_non_modal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_set_non_modal" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      (arg1)->set_non_modal(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_non_modal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_non_modal" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (unsigned int)((Fl_Window const *)arg1)->non_modal(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_clear_modal_states(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_clear_modal_states" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      (arg1)->clear_modal_states(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_set_menu_window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_set_menu_window" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      (arg1)->set_menu_window(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_menu_window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_menu_window" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (unsigned int)((Fl_Window const *)arg1)->menu_window(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_set_tooltip_window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_set_tooltip_window" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      (arg1)->set_tooltip_window(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_tooltip_window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_tooltip_window" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (unsigned int)((Fl_Window const *)arg1)->tooltip_window(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_hotspot__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 = (int) 0 ;
  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 < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_hotspot" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_hotspot" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_hotspot" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Window_hotspot" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  {
    try {
      (arg1)->hotspot(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_hotspot__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  int arg3 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_hotspot" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Window_hotspot" "', argument " "2"" of type '" "Fl_Widget const *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_hotspot" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      (arg1)->hotspot((Fl_Widget const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_hotspot(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Window_hotspot", 0, 4, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Widget, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_Fl_Window_hotspot__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if ((argc >= 3) && (argc <= 4)) {
    PyObject *retobj = _wrap_Fl_Window_hotspot__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Window_hotspot'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Window::hotspot(int,int,int)\n"
    "    Fl_Window::hotspot(Fl_Widget const *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Window_free_position(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_free_position" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      (arg1)->free_position(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_size_range(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 = (int) 0 ;
  int arg5 = (int) 0 ;
  int arg6 = (int) 0 ;
  int arg7 = (int) 0 ;
  int arg8 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject *swig_obj[8] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Window_size_range", 3, 8, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_size_range" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_size_range" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_size_range" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Window_size_range" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Window_size_range" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = (int)(val5);
  }
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Window_size_range" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Window_size_range" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  if (swig_obj[7]) {
    ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Fl_Window_size_range" "', argument " "8"" of type '" "int""'");
    } 
    arg8 = (int)(val8);
  }
  {
    try {
      (arg1)->size_range(arg2,arg3,arg4,arg5,arg6,arg7,arg8); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_get_size_range(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  int *arg4 = (int *) NULL ;
  int *arg5 = (int *) NULL ;
  int *arg6 = (int *) NULL ;
  int *arg7 = (int *) NULL ;
  int *arg8 = (int *) NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject *swig_obj[8] ;
  uchar result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Window_get_size_range", 3, 8, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_get_size_range" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(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 '" "Fl_Window_get_size_range" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (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 '" "Fl_Window_get_size_range" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  if (swig_obj[3]) {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Window_get_size_range" "', argument " "4"" of type '" "int *""'"); 
    }
    arg4 = (int *)(argp4);
  }
  if (swig_obj[4]) {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 |  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Fl_Window_get_size_range" "', argument " "5"" of type '" "int *""'"); 
    }
    arg5 = (int *)(argp5);
  }
  if (swig_obj[5]) {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_int, 0 |  0 );
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Fl_Window_get_size_range" "', argument " "6"" of type '" "int *""'"); 
    }
    arg6 = (int *)(argp6);
  }
  if (swig_obj[6]) {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_int, 0 |  0 );
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Fl_Window_get_size_range" "', argument " "7"" of type '" "int *""'"); 
    }
    arg7 = (int *)(argp7);
  }
  if (swig_obj[7]) {
    res8 = SWIG_ConvertPtr(swig_obj[7], &argp8,SWIGTYPE_p_int, 0 |  0 );
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Fl_Window_get_size_range" "', argument " "8"" of type '" "int *""'"); 
    }
    arg8 = (int *)(argp8);
  }
  {
    try {
      result = (uchar)((Fl_Window const *)arg1)->get_size_range(arg2,arg3,arg4,arg5,arg6,arg7,arg8); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_label__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_label" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (char *)((Fl_Window const *)arg1)->label(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_iconlabel__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_iconlabel" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (char *)((Fl_Window const *)arg1)->iconlabel(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_label__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_label" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Window_label" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->label((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_iconlabel__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_iconlabel" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Window_iconlabel" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->iconlabel((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_iconlabel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Window_iconlabel", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Window_iconlabel__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Window_iconlabel__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Window_iconlabel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Window::iconlabel() const\n"
    "    Fl_Window::iconlabel(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Window_label__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 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;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_label" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Window_label" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Window_label" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      (arg1)->label((char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_label(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Window_label", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Window_label__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Window_label__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Window_label__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Window_label'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Window::label() const\n"
    "    Fl_Window::label(char const *)\n"
    "    Fl_Window::label(char const *,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Window_copy_label(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 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, "Fl_Window_copy_label", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_copy_label" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Window_copy_label" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->copy_label((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_default_xclass__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  
  (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 '" "Fl_Window_default_xclass" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      Fl_Window::default_xclass((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_default_xclass__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (char *)Fl_Window::default_xclass(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_default_xclass(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Window_default_xclass", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_Fl_Window_default_xclass__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Window_default_xclass__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Window_default_xclass'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Window::default_xclass(char const *)\n"
    "    Fl_Window::default_xclass()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Window_xclass__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_xclass" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (char *)((Fl_Window const *)arg1)->xclass(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_xclass__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_xclass" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Window_xclass" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->xclass((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_xclass(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Window_xclass", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Window_xclass__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Window_xclass__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Window_xclass'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Window::xclass() const\n"
    "    Fl_Window::xclass(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Window_default_icon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_default_icon" "', argument " "1"" of type '" "Fl_RGB_Image const *""'"); 
  }
  arg1 = (Fl_RGB_Image *)(argp1);
  {
    try {
      Fl_Window::default_icon((Fl_RGB_Image const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_default_icons(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Image **arg1 = (Fl_RGB_Image **) (Fl_RGB_Image **)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, "Fl_Window_default_icons", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_p_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_default_icons" "', argument " "1"" of type '" "Fl_RGB_Image const *[]""'"); 
  } 
  arg1 = (Fl_RGB_Image **)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_default_icons" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      Fl_Window::default_icons((Fl_RGB_Image const *(*))arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_icon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  Fl_RGB_Image *arg2 = (Fl_RGB_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_icon" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Window_icon" "', argument " "2"" of type '" "Fl_RGB_Image const *""'"); 
  }
  arg2 = (Fl_RGB_Image *)(argp2);
  {
    try {
      (arg1)->icon((Fl_RGB_Image const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_icons(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  Fl_RGB_Image **arg2 = (Fl_RGB_Image **) (Fl_RGB_Image **)0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Window_icons", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_icons" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Window_icons" "', argument " "2"" of type '" "Fl_RGB_Image const *[]""'"); 
  } 
  arg2 = (Fl_RGB_Image **)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_icons" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->icons((Fl_RGB_Image const *(*))arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_icon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 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_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_icon" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (void *)((Fl_Window const *)arg1)->icon(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_icon__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_icon" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(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 '" "Fl_Window_icon" "', argument " "2"" of type '" "void const *""'"); 
  }
  {
    try {
      (arg1)->icon((void const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_icon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Window_icon", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Window_icon__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_RGB_Image, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_Fl_Window_icon__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Window_icon__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Window_icon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Window::icon(Fl_RGB_Image const *)\n"
    "    Fl_Window::icon() const\n"
    "    Fl_Window::icon(void const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Window_shown(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 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_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_shown" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (int)((Fl_Window const *)arg1)->shown(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_hide(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_hide" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Window::hide();
        } else {
          (arg1)->hide();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_wait_for_expose(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_wait_for_expose" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      (arg1)->wait_for_expose(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_fullscreen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_fullscreen" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      (arg1)->fullscreen(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_fullscreen_off__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 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_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_fullscreen_off" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      (arg1)->fullscreen_off(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_fullscreen_off__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_fullscreen_off" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_fullscreen_off" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_fullscreen_off" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Window_fullscreen_off" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Window_fullscreen_off" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      (arg1)->fullscreen_off(arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_fullscreen_off(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Window_fullscreen_off", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Window_fullscreen_off__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_Fl_Window_fullscreen_off__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Window_fullscreen_off'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Window::fullscreen_off()\n"
    "    Fl_Window::fullscreen_off(int,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Window_fullscreen_active(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_fullscreen_active" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (unsigned int)((Fl_Window const *)arg1)->fullscreen_active(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_fullscreen_screens(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Window_fullscreen_screens", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_fullscreen_screens" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_fullscreen_screens" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_fullscreen_screens" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Window_fullscreen_screens" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Window_fullscreen_screens" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      (arg1)->fullscreen_screens(arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_maximize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_maximize" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      (arg1)->maximize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_un_maximize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_un_maximize" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      (arg1)->un_maximize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_maximize_active(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_maximize_active" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (unsigned int)((Fl_Window const *)arg1)->maximize_active(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_iconize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_iconize" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      (arg1)->iconize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_x_root(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 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_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_x_root" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (int)((Fl_Window const *)arg1)->x_root(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_y_root(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 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_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_y_root" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (int)((Fl_Window const *)arg1)->y_root(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swig::Director *director = 0;
  Fl_Window *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Window_current", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Window *)Fl_Window::current(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_make_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_make_current" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      (arg1)->make_current(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_cursor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  Fl_Cursor 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_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_cursor" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_cursor" "', argument " "2"" of type '" "Fl_Cursor""'");
  } 
  arg2 = (Fl_Cursor)(val2);
  {
    try {
      (arg1)->cursor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_cursor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  Fl_RGB_Image *arg2 = (Fl_RGB_Image *) 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_cursor" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Window_cursor" "', argument " "2"" of type '" "Fl_RGB_Image const *""'"); 
  }
  arg2 = (Fl_RGB_Image *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_cursor" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Window_cursor" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      (arg1)->cursor((Fl_RGB_Image const *)arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_default_cursor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  Fl_Cursor 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_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_default_cursor" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_default_cursor" "', argument " "2"" of type '" "Fl_Cursor""'");
  } 
  arg2 = (Fl_Cursor)(val2);
  {
    try {
      (arg1)->default_cursor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_cursor__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  Fl_Cursor arg2 ;
  Fl_Color arg3 ;
  Fl_Color arg4 = (Fl_Color) FL_WHITE ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_cursor" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_cursor" "', argument " "2"" of type '" "Fl_Cursor""'");
  } 
  arg2 = (Fl_Cursor)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_cursor" "', argument " "3"" of type '" "Fl_Color""'");
  } 
  arg3 = (Fl_Color)(val3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Window_cursor" "', argument " "4"" of type '" "Fl_Color""'");
    } 
    arg4 = (Fl_Color)(val4);
  }
  {
    try {
      (arg1)->cursor(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_cursor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Window_cursor", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Window_cursor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    if (argc > 3) {
      {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (!_v) goto check_2;
    }
    return _wrap_Fl_Window_cursor__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_Fl_Window_cursor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Window_cursor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Window::cursor(Fl_Cursor)\n"
    "    Fl_Window::cursor(Fl_RGB_Image const *,int,int)\n"
    "    Fl_Window::cursor(Fl_Cursor,Fl_Color,Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Window_default_cursor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  Fl_Cursor arg2 ;
  Fl_Color arg3 ;
  Fl_Color arg4 = (Fl_Color) FL_WHITE ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_default_cursor" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_default_cursor" "', argument " "2"" of type '" "Fl_Cursor""'");
  } 
  arg2 = (Fl_Cursor)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_default_cursor" "', argument " "3"" of type '" "Fl_Color""'");
  } 
  arg3 = (Fl_Color)(val3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Window_default_cursor" "', argument " "4"" of type '" "Fl_Color""'");
    } 
    arg4 = (Fl_Color)(val4);
  }
  {
    try {
      (arg1)->default_cursor(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_default_cursor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Window_default_cursor", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Window_default_cursor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 3) && (argc <= 4)) {
    PyObject *retobj = _wrap_Fl_Window_default_cursor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Window_default_cursor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Window::default_cursor(Fl_Cursor)\n"
    "    Fl_Window::default_cursor(Fl_Cursor,Fl_Color,Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Window_default_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Window_default_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_default_callback" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(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 '" "Fl_Window_default_callback" "', argument " "2"" of type '" "void *""'"); 
  }
  {
    try {
      Fl_Window::default_callback(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_decorated_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 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_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_decorated_w" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (int)((Fl_Window const *)arg1)->decorated_w(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_decorated_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 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_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_decorated_h" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (int)((Fl_Window const *)arg1)->decorated_h(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_as_window__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_as_window" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Window *)(arg1)->Fl_Window::as_window();
        } else {
          result = (Fl_Window *)(arg1)->as_window();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, 0 |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_as_window__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_as_window" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Window *)((Fl_Window const *)arg1)->Fl_Window::as_window();
        } else {
          result = (Fl_Window *)((Fl_Window const *)arg1)->as_window();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, 0 |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_as_window(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Window_as_window", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Window_as_window__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Window_as_window__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Window_as_window'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Window::as_window()\n"
    "    Fl_Window::as_window() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Window_as_overlay_window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Overlay_Window *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_as_overlay_window" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Overlay_Window *)(arg1)->Fl_Window::as_overlay_window();
        } else {
          result = (Fl_Overlay_Window *)(arg1)->as_overlay_window();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Overlay_Window, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_as_double_window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Double_Window *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_as_double_window" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Double_Window *)(arg1)->Fl_Window::as_double_window();
        } else {
          result = (Fl_Double_Window *)(arg1)->as_double_window();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Double_Window, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_shape__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  Fl_Image *arg2 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_shape" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Window_shape" "', argument " "2"" of type '" "Fl_Image const *""'"); 
  }
  arg2 = (Fl_Image *)(argp2);
  {
    try {
      (arg1)->shape((Fl_Image const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_shape__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  Fl_Image *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_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_shape" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Image,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Window_shape" "', argument " "2"" of type '" "Fl_Image const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Window_shape" "', argument " "2"" of type '" "Fl_Image const &""'"); 
  }
  arg2 = (Fl_Image *)(argp2);
  {
    try {
      (arg1)->shape((Fl_Image const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_shape__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_shape" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Window const *)arg1)->shape(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_shape(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Window_shape", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Window_shape__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Fl_Image, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_Fl_Window_shape__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Window_shape__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Window_shape'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Window::shape(Fl_Image const *)\n"
    "    Fl_Window::shape(Fl_Image const &)\n"
    "    Fl_Window::shape() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Window_draw_backdrop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_draw_backdrop" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      (arg1)->draw_backdrop(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_screen_num__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 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_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_screen_num" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (int)((Fl_Window const *)arg1)->screen_num(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_screen_num__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 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_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_screen_num" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_screen_num" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->screen_num(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_screen_num(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Window_screen_num", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Window_screen_num__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Window_screen_num__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Window_screen_num'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Window::screen_num() const\n"
    "    Fl_Window::screen_num(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Window_is_a_rescale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Window_is_a_rescale", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (bool)Fl_Window::is_a_rescale(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_os_id(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  fl_uintptr_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_os_id" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = ((Fl_Window const *)arg1)->os_id(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new fl_uintptr_t(result)), SWIGTYPE_p_fl_uintptr_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_show_next_window_iconic__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char arg1 ;
  char val1 ;
  int ecode1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Window_show_next_window_iconic" "', argument " "1"" of type '" "char""'");
  } 
  arg1 = (char)(val1);
  {
    try {
      Fl_Window::show_next_window_iconic(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_show_next_window_iconic__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  char result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (char)Fl_Window::show_next_window_iconic(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new char(result)), SWIGTYPE_p_char, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_show_next_window_iconic(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Window_show_next_window_iconic", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_Fl_Window_show_next_window_iconic__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Window_show_next_window_iconic__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Window_show_next_window_iconic'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Window::show_next_window_iconic(char)\n"
    "    Fl_Window::show_next_window_iconic()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Window_allow_expand_outside_parent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_allow_expand_outside_parent" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      (arg1)->allow_expand_outside_parent(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 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, "Fl_Window_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_init_type" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Window_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Window_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_show(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Window_show", 1, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Window_show" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  if (swig_obj[1]) {
    arg2 = swig_obj[1];
  }
  if (swig_obj[2]) {
    arg3 = swig_obj[2];
  }
  {
    try {
      Fl_Window_show(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Window" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Double_Window_as_double_window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Double_Window *arg1 = (Fl_Double_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Double_Window *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Double_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Double_Window_as_double_window" "', argument " "1"" of type '" "Fl_Double_Window *""'"); 
  }
  arg1 = (Fl_Double_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Double_Window *)(arg1)->Fl_Double_Window::as_double_window();
        } else {
          result = (Fl_Double_Window *)(arg1)->as_double_window();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Double_Window, 0 |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Double_Window_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Double_Window *arg1 = (Fl_Double_Window *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Double_Window_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Double_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Double_Window_resize" "', argument " "1"" of type '" "Fl_Double_Window *""'"); 
  }
  arg1 = (Fl_Double_Window *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Double_Window_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Double_Window_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Double_Window_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Double_Window_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Double_Window::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Double_Window_hide(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Double_Window *arg1 = (Fl_Double_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Double_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Double_Window_hide" "', argument " "1"" of type '" "Fl_Double_Window *""'"); 
  }
  arg1 = (Fl_Double_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Double_Window::hide();
        } else {
          (arg1)->hide();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Double_Window_flush(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Double_Window *arg1 = (Fl_Double_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Double_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Double_Window_flush" "', argument " "1"" of type '" "Fl_Double_Window *""'"); 
  }
  arg1 = (Fl_Double_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Double_Window::flush();
        } else {
          (arg1)->flush();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Double_Window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Double_Window *arg1 = (Fl_Double_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Double_Window, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Double_Window" "', argument " "1"" of type '" "Fl_Double_Window *""'"); 
  }
  arg1 = (Fl_Double_Window *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Double_Window__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  char *arg4 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  Fl_Double_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Double_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Double_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  if (swig_obj[3]) {
    res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Fl_Double_Window" "', argument " "4"" of type '" "char const *""'");
    }
    arg4 = (char *)(buf4);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Double_Window *)new SwigDirector_Fl_Double_Window(arg1,arg2,arg3,(char const *)arg4); 
      } else {
        result = (Fl_Double_Window *)new Fl_Double_Window(arg2,arg3,(char const *)arg4); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Double_Window, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Double_Window__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  Fl_Double_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Double_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Double_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Double_Window" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Double_Window" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Double_Window" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Double_Window *)new SwigDirector_Fl_Double_Window(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Double_Window *)new Fl_Double_Window(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Double_Window, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Double_Window(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_Double_Window", 0, 6, argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    PyObject *retobj = _wrap_new_Fl_Double_Window__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 5) && (argc <= 6)) {
    PyObject *retobj = _wrap_new_Fl_Double_Window__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_Double_Window'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Double_Window::Fl_Double_Window(int,int,char const *)\n"
    "    Fl_Double_Window::Fl_Double_Window(PyObject *,int,int,int,int,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Double_Window_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Double_Window *arg1 = (Fl_Double_Window *) 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, "Fl_Double_Window_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Double_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Double_Window_init_type" "', argument " "1"" of type '" "Fl_Double_Window *""'"); 
  }
  arg1 = (Fl_Double_Window *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Double_Window_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Double_Window_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Double_Window_show(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Double_Window *arg1 = (Fl_Double_Window *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Double_Window_show", 1, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Double_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Double_Window_show" "', argument " "1"" of type '" "Fl_Double_Window *""'"); 
  }
  arg1 = (Fl_Double_Window *)(argp1);
  if (swig_obj[1]) {
    arg2 = swig_obj[1];
  }
  if (swig_obj[2]) {
    arg3 = swig_obj[2];
  }
  {
    try {
      Fl_Double_Window_show(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Double_Window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Double_Window *arg1 = (Fl_Double_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Double_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Double_Window" "', argument " "1"" of type '" "Fl_Double_Window *""'"); 
  }
  arg1 = (Fl_Double_Window *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Double_Window_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Double_Window *arg1 = (Fl_Double_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Double_Window *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Double_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Double_Window_draw" "', argument " "1"" of type '" "Fl_Double_Window *""'"); 
  }
  arg1 = (Fl_Double_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Double_Window *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_fl_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  {
    try {
      fl_color(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  uchar arg1 ;
  uchar arg2 ;
  uchar arg3 ;
  unsigned char val1 ;
  int ecode1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_color" "', argument " "1"" of type '" "uchar""'");
  } 
  arg1 = (uchar)(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_color" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_color" "', argument " "3"" of type '" "uchar""'");
  } 
  arg3 = (uchar)(val3);
  {
    try {
      fl_color(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_color__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Fl_Color)fl_color(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_color", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_fl_color__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_fl_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_fl_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_color(Fl_Color)\n"
    "    fl_color(uchar,uchar,uchar)\n"
    "    fl_color()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_push_clip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_push_clip", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_push_clip" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_push_clip" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_push_clip" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_push_clip" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      fl_push_clip(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_push_no_clip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_push_no_clip", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_push_no_clip(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_pop_clip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_pop_clip", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_pop_clip(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_not_clipped(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_not_clipped", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_not_clipped" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_not_clipped" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_not_clipped" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_not_clipped" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      result = (int)fl_not_clipped(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_clip_box(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int *arg5 = 0 ;
  int *arg6 = 0 ;
  int *arg7 = 0 ;
  int *arg8 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int temp5 ;
  int res5 = SWIG_TMPOBJ ;
  int temp6 ;
  int res6 = SWIG_TMPOBJ ;
  int temp7 ;
  int res7 = SWIG_TMPOBJ ;
  int temp8 ;
  int res8 = SWIG_TMPOBJ ;
  PyObject *swig_obj[4] ;
  int result;
  
  arg5 = &temp5;
  arg6 = &temp6;
  arg7 = &temp7;
  arg8 = &temp8;
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_clip_box", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_clip_box" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_clip_box" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_clip_box" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_clip_box" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      result = (int)fl_clip_box(arg1,arg2,arg3,arg4,*arg5,*arg6,*arg7,*arg8); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg7)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_int, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res8)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg8)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_int, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_restore_clip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_restore_clip", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_restore_clip(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_clip_region__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Region arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Region,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_clip_region" "', argument " "1"" of type '" "Fl_Region""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_clip_region" "', argument " "1"" of type '" "Fl_Region""'");
    } else {
      Fl_Region * temp = (Fl_Region *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      fl_clip_region(SWIG_STD_MOVE(arg1)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_clip_region__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Fl_Region result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = fl_clip_region(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new Fl_Region(result)), SWIGTYPE_p_Fl_Region, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_clip_region(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_clip_region", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_fl_clip_region__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_fl_clip_region__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_clip_region'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_clip_region(Fl_Region)\n"
    "    fl_clip_region()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_point(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_point", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_point" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_point" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      fl_point(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_line_style(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 = (int) 0 ;
  char *arg3 = (char *) 0 ;
  int val1 ;
  int ecode1 = 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, "fl_line_style", 1, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_line_style" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_line_style" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  if (swig_obj[2]) {
    res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_line_style" "', argument " "3"" of type '" "char *""'");
    }
    arg3 = (char *)(buf3);
  }
  {
    try {
      fl_line_style(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_antialias__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 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 '" "fl_antialias" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      fl_antialias(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_antialias__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)fl_antialias(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_antialias(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_antialias", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_fl_antialias__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_fl_antialias__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_antialias'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_antialias(int)\n"
    "    fl_antialias()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_rect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 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;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_rect" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_rect" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_rect" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_rect" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      fl_rect(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rounded_rect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_rounded_rect", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_rounded_rect" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_rounded_rect" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_rounded_rect" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_rounded_rect" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_rounded_rect" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      fl_rounded_rect(arg1,arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Rect arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Rect,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_rect" "', argument " "1"" of type '" "Fl_Rect""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_rect" "', argument " "1"" of type '" "Fl_Rect""'");
    } else {
      Fl_Rect * temp = (Fl_Rect *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      fl_rect(SWIG_STD_MOVE(arg1)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_focus_rect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_focus_rect", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_focus_rect" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_focus_rect" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_focus_rect" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_focus_rect" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      fl_focus_rect(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rect__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  Fl_Color arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_rect" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_rect" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_rect" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_rect" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_rect" "', argument " "5"" of type '" "Fl_Color""'");
  } 
  arg5 = (Fl_Color)(val5);
  {
    try {
      fl_rect(arg1,arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_rect", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_fl_rect__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_fl_rect__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_fl_rect__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_rect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_rect(int,int,int,int)\n"
    "    fl_rect(Fl_Rect)\n"
    "    fl_rect(int,int,int,int,Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_rectf__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 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;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_rectf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_rectf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_rectf" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_rectf" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      fl_rectf(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rounded_rectf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_rounded_rectf", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_rounded_rectf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_rounded_rectf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_rounded_rectf" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_rounded_rectf" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_rounded_rectf" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      fl_rounded_rectf(arg1,arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rectf__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  Fl_Color arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_rectf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_rectf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_rectf" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_rectf" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_rectf" "', argument " "5"" of type '" "Fl_Color""'");
  } 
  arg5 = (Fl_Color)(val5);
  {
    try {
      fl_rectf(arg1,arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rectf__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Rect arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Rect,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_rectf" "', argument " "1"" of type '" "Fl_Rect""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_rectf" "', argument " "1"" of type '" "Fl_Rect""'");
    } else {
      Fl_Rect * temp = (Fl_Rect *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      fl_rectf(SWIG_STD_MOVE(arg1)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rectf__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Rect arg1 ;
  Fl_Color arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Rect,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_rectf" "', argument " "1"" of type '" "Fl_Rect""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_rectf" "', argument " "1"" of type '" "Fl_Rect""'");
    } else {
      Fl_Rect * temp = (Fl_Rect *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_rectf" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      fl_rectf(SWIG_STD_MOVE(arg1),arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rectf__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  uchar arg5 ;
  uchar arg6 ;
  uchar arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned char val5 ;
  int ecode5 = 0 ;
  unsigned char val6 ;
  int ecode6 = 0 ;
  unsigned char val7 ;
  int ecode7 = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_rectf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_rectf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_rectf" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_rectf" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_rectf" "', argument " "5"" of type '" "uchar""'");
  } 
  arg5 = (uchar)(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_rectf" "', argument " "6"" of type '" "uchar""'");
  } 
  arg6 = (uchar)(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fl_rectf" "', argument " "7"" of type '" "uchar""'");
  } 
  arg7 = (uchar)(val7);
  {
    try {
      fl_rectf(arg1,arg2,arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rectf__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Rect arg1 ;
  uchar arg2 ;
  uchar arg3 ;
  uchar arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  unsigned char val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Rect,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_rectf" "', argument " "1"" of type '" "Fl_Rect""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_rectf" "', argument " "1"" of type '" "Fl_Rect""'");
    } else {
      Fl_Rect * temp = (Fl_Rect *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_rectf" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_rectf" "', argument " "3"" of type '" "uchar""'");
  } 
  arg3 = (uchar)(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_rectf" "', argument " "4"" of type '" "uchar""'");
  } 
  arg4 = (uchar)(val4);
  {
    try {
      fl_rectf(SWIG_STD_MOVE(arg1),arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rectf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_rectf", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_fl_rectf__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_fl_rectf__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Fl_Rect, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_char(argv[3], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    return _wrap_fl_rectf__SWIG_5(self, argc, argv);
  }
check_3:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_fl_rectf__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_fl_rectf__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_fl_rectf__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_rectf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_rectf(int,int,int,int)\n"
    "    fl_rectf(int,int,int,int,Fl_Color)\n"
    "    fl_rectf(Fl_Rect)\n"
    "    fl_rectf(Fl_Rect,Fl_Color)\n"
    "    fl_rectf(int,int,int,int,uchar,uchar,uchar)\n"
    "    fl_rectf(Fl_Rect,uchar,uchar,uchar)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_line__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 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;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_line" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_line" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_line" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_line" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      fl_line(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_line__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_line" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_line" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_line" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_line" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_line" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_line" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  {
    try {
      fl_line(arg1,arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_line(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_line", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    PyObject *retobj = _wrap_fl_line__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_fl_line__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_line'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_line(int,int,int,int)\n"
    "    fl_line(int,int,int,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_loop__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_loop" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_loop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_loop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_loop" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_loop" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_loop" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  {
    try {
      fl_loop(arg1,arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_loop__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_loop" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_loop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_loop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_loop" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_loop" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_loop" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fl_loop" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = (int)(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "fl_loop" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = (int)(val8);
  {
    try {
      fl_loop(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_loop(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_loop", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    PyObject *retobj = _wrap_fl_loop__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 8) {
    PyObject *retobj = _wrap_fl_loop__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_loop'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_loop(int,int,int,int,int,int)\n"
    "    fl_loop(int,int,int,int,int,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_polygon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_polygon" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_polygon" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_polygon" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_polygon" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_polygon" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_polygon" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  {
    try {
      fl_polygon(arg1,arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_polygon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_polygon" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_polygon" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_polygon" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_polygon" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_polygon" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_polygon" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fl_polygon" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = (int)(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "fl_polygon" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = (int)(val8);
  {
    try {
      fl_polygon(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_polygon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_polygon", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    PyObject *retobj = _wrap_fl_polygon__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 8) {
    PyObject *retobj = _wrap_fl_polygon__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_polygon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_polygon(int,int,int,int,int,int)\n"
    "    fl_polygon(int,int,int,int,int,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_xyline__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_xyline" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_xyline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_xyline" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      fl_xyline(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_xyline__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 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;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_xyline" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_xyline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_xyline" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_xyline" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      fl_xyline(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_xyline__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_xyline" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_xyline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_xyline" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_xyline" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_xyline" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      fl_xyline(arg1,arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_xyline(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_xyline", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_fl_xyline__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_fl_xyline__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_fl_xyline__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_xyline'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_xyline(int,int,int)\n"
    "    fl_xyline(int,int,int,int)\n"
    "    fl_xyline(int,int,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_yxline__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_yxline" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_yxline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_yxline" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      fl_yxline(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_yxline__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 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;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_yxline" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_yxline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_yxline" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_yxline" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      fl_yxline(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_yxline__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_yxline" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_yxline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_yxline" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_yxline" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_yxline" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      fl_yxline(arg1,arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_yxline(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_yxline", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_fl_yxline__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_fl_yxline__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_fl_yxline__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_yxline'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_yxline(int,int,int)\n"
    "    fl_yxline(int,int,int,int)\n"
    "    fl_yxline(int,int,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_arc__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  double arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_arc" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_arc" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_arc" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_arc" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_arc" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_arc" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = (double)(val6);
  {
    try {
      fl_arc(arg1,arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_pie(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  double arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_pie", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_pie" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_pie" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_pie" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_pie" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_pie" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_pie" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = (double)(val6);
  {
    try {
      fl_pie(arg1,arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_push_matrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_push_matrix", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_push_matrix(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_pop_matrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_pop_matrix", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_pop_matrix(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_scale__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_scale" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_scale" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      fl_scale(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_scale__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 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 '" "fl_scale" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  {
    try {
      fl_scale(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_scale(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_scale", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_fl_scale__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_fl_scale__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_scale'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_scale(double,double)\n"
    "    fl_scale(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_translate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_translate", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_translate" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_translate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      fl_translate(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rotate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_rotate" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  {
    try {
      fl_rotate(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_load_identity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_load_identity", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_load_identity(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_load_matrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_load_matrix", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_load_matrix" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_load_matrix" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_load_matrix" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_load_matrix" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_load_matrix" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_load_matrix" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = (double)(val6);
  {
    try {
      fl_load_matrix(arg1,arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_mult_matrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_mult_matrix", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_mult_matrix" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_mult_matrix" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_mult_matrix" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_mult_matrix" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_mult_matrix" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_mult_matrix" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = (double)(val6);
  {
    try {
      fl_mult_matrix(arg1,arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_begin_points(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_begin_points", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_begin_points(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_begin_line(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_begin_line", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_begin_line(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_begin_loop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_begin_loop", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_begin_loop(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_begin_polygon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_begin_polygon", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_begin_polygon(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_vertex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_vertex", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_vertex" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_vertex" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      fl_vertex(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_curve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject *swig_obj[8] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_curve", 8, 8, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_curve" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_curve" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_curve" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_curve" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_curve" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_curve" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = (double)(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fl_curve" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = (double)(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "fl_curve" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = (double)(val8);
  {
    try {
      fl_curve(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_arc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_arc" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_arc" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_arc" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_arc" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_arc" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = (double)(val5);
  {
    try {
      fl_arc(arg1,arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_arc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_arc", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    PyObject *retobj = _wrap_fl_arc__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_fl_arc__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_arc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_arc(int,int,int,int,double,double)\n"
    "    fl_arc(double,double,double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_circle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_circle", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_circle" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_circle" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_circle" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  {
    try {
      fl_circle(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_end_points(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_end_points", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_end_points(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_end_line(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_end_line", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_end_line(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_end_loop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_end_loop", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_end_loop(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_end_polygon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_end_polygon", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_end_polygon(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_begin_complex_polygon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_begin_complex_polygon", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_begin_complex_polygon(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_gap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_gap", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_gap(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_end_complex_polygon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_end_complex_polygon", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_end_complex_polygon(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_transform_x(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_transform_x", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_transform_x" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_transform_x" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      result = (double)fl_transform_x(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_transform_y(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_transform_y", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_transform_y" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_transform_y" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      result = (double)fl_transform_y(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_transform_dx(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_transform_dx", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_transform_dx" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_transform_dx" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      result = (double)fl_transform_dx(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_transform_dy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_transform_dy", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_transform_dy" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_transform_dy" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      result = (double)fl_transform_dy(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_transformed_vertex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_transformed_vertex", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_transformed_vertex" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = (double)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_transformed_vertex" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      fl_transformed_vertex(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_copy_offscreen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  Fl_Offscreen arg5 ;
  int arg6 ;
  int arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_copy_offscreen", 7, 7, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_copy_offscreen" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_copy_offscreen" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_copy_offscreen" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_copy_offscreen" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Fl_Offscreen,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "fl_copy_offscreen" "', argument " "5"" of type '" "Fl_Offscreen""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_copy_offscreen" "', argument " "5"" of type '" "Fl_Offscreen""'");
    } else {
      Fl_Offscreen * temp = (Fl_Offscreen *)(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_copy_offscreen" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fl_copy_offscreen" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = (int)(val7);
  {
    try {
      fl_copy_offscreen(arg1,arg2,arg3,arg4,SWIG_STD_MOVE(arg5),arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_create_offscreen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Fl_Offscreen result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_create_offscreen", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_create_offscreen" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_create_offscreen" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = fl_create_offscreen(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new Fl_Offscreen(result)), SWIGTYPE_p_Fl_Offscreen, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_begin_offscreen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Offscreen arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Offscreen,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_begin_offscreen" "', argument " "1"" of type '" "Fl_Offscreen""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_begin_offscreen" "', argument " "1"" of type '" "Fl_Offscreen""'");
    } else {
      Fl_Offscreen * temp = (Fl_Offscreen *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      fl_begin_offscreen(SWIG_STD_MOVE(arg1)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_end_offscreen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_end_offscreen", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_end_offscreen(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_delete_offscreen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Offscreen arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Offscreen,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_delete_offscreen" "', argument " "1"" of type '" "Fl_Offscreen""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_delete_offscreen" "', argument " "1"" of type '" "Fl_Offscreen""'");
    } else {
      Fl_Offscreen * temp = (Fl_Offscreen *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      fl_delete_offscreen(SWIG_STD_MOVE(arg1)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rescale_offscreen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Offscreen *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Offscreen,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_rescale_offscreen" "', argument " "1"" of type '" "Fl_Offscreen &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_rescale_offscreen" "', argument " "1"" of type '" "Fl_Offscreen &""'"); 
  }
  arg1 = (Fl_Offscreen *)(argp1);
  {
    try {
      fl_rescale_offscreen(*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_font__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Font arg1 ;
  Fl_Fontsize arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 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 '" "fl_font" "', argument " "1"" of type '" "Fl_Font""'");
  } 
  arg1 = (Fl_Font)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_font" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      fl_font(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_font__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Fl_Font)fl_font(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_font(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_font", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_fl_font__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_fl_font__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_font'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_font(Fl_Font,Fl_Fontsize)\n"
    "    fl_font()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Fontsize result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_size", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Fontsize)fl_size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_height__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)fl_height(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_height__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  (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 '" "fl_height" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_height" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)fl_height(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_height(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_height", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_fl_height__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_fl_height__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_height'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_height()\n"
    "    fl_height(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_descent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_descent", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)fl_descent(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_width__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  double 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 '" "fl_width" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (double)fl_width((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_width__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double result;
  
  (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 '" "fl_width" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (double)fl_width((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_width__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  double result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_width" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = (unsigned int)(val1);
  {
    try {
      result = (double)fl_width(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_width(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_width", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_fl_width__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_fl_width__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_fl_width__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_width'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_width(char const *)\n"
    "    fl_width(char const *,int)\n"
    "    fl_width(unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_text_extents__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int *arg5 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  int temp5 ;
  int res5 = SWIG_TMPOBJ ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  (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 '" "fl_text_extents" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      fl_text_extents((char const *)arg1,*arg2,*arg3,*arg4,*arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_text_extents__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int *arg5 = 0 ;
  int *arg6 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  int temp5 ;
  int res5 = SWIG_TMPOBJ ;
  int temp6 ;
  int res6 = SWIG_TMPOBJ ;
  
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  arg6 = &temp6;
  (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 '" "fl_text_extents" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_text_extents" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      fl_text_extents((char const *)arg1,arg2,*arg3,*arg4,*arg5,*arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags), 1);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_text_extents(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_text_extents", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_fl_text_extents__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_fl_text_extents__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_text_extents'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_text_extents(char const *,int &,int &,int &,int &)\n"
    "    fl_text_extents(char const *,int,int &,int &,int &,int &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_latin1_to_local(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 = (int) -1 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_latin1_to_local", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_latin1_to_local" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_latin1_to_local" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      result = (char *)fl_latin1_to_local((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_local_to_latin1(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 = (int) -1 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_local_to_latin1", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_local_to_latin1" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_local_to_latin1" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      result = (char *)fl_local_to_latin1((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_mac_roman_to_local(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 = (int) -1 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_mac_roman_to_local", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_mac_roman_to_local" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_mac_roman_to_local" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      result = (char *)fl_mac_roman_to_local((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_local_to_mac_roman(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 = (int) -1 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_local_to_mac_roman", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_local_to_mac_roman" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_local_to_mac_roman" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      result = (char *)fl_local_to_mac_roman((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_override_scale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_override_scale", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (float)fl_override_scale(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_float((float)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_restore_scale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_restore_scale" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = (float)(val1);
  {
    try {
      fl_restore_scale(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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 '" "fl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      fl_draw((char const *)arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_draw" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_draw" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      fl_draw(arg1,(char const *)arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 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_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      fl_draw((char const *)arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_draw" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_draw" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      fl_draw(arg1,(char const *)arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rtl_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_rtl_draw", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_rtl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_rtl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_rtl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_rtl_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      fl_rtl_draw((char const *)arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  Fl_Align arg6 ;
  Fl_Image *arg7 = (Fl_Image *) 0 ;
  int arg8 = (int) 1 ;
  int arg9 = (int) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_draw" "', argument " "6"" of type '" "Fl_Align""'");
  } 
  arg6 = (Fl_Align)(val6);
  if (swig_obj[6]) {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_Fl_Image, 0 |  0 );
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "fl_draw" "', argument " "7"" of type '" "Fl_Image *""'"); 
    }
    arg7 = (Fl_Image *)(argp7);
  }
  if (swig_obj[7]) {
    ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "fl_draw" "', argument " "8"" of type '" "int""'");
    } 
    arg8 = (int)(val8);
  }
  if (swig_obj[8]) {
    ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "fl_draw" "', argument " "9"" of type '" "int""'");
    } 
    arg9 = (int)(val9);
  }
  {
    try {
      fl_draw((char const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  Fl_Align arg6 ;
  void (*arg7)(char const *,int,int,int) = (void (*)(char const *,int,int,int)) 0 ;
  Fl_Image *arg8 = (Fl_Image *) 0 ;
  int arg9 = (int) 1 ;
  int arg10 = (int) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_draw" "', argument " "6"" of type '" "Fl_Align""'");
  } 
  arg6 = (Fl_Align)(val6);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[6], (void**)(&arg7), SWIGTYPE_p_f_p_q_const__char_int_int_int__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "fl_draw" "', argument " "7"" of type '" "void (*)(char const *,int,int,int)""'"); 
    }
  }
  if (swig_obj[7]) {
    res8 = SWIG_ConvertPtr(swig_obj[7], &argp8,SWIGTYPE_p_Fl_Image, 0 |  0 );
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "fl_draw" "', argument " "8"" of type '" "Fl_Image *""'"); 
    }
    arg8 = (Fl_Image *)(argp8);
  }
  if (swig_obj[8]) {
    ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "fl_draw" "', argument " "9"" of type '" "int""'");
    } 
    arg9 = (int)(val9);
  }
  if (swig_obj[9]) {
    ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
    if (!SWIG_IsOK(ecode10)) {
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "fl_draw" "', argument " "10"" of type '" "int""'");
    } 
    arg10 = (int)(val10);
  }
  {
    try {
      fl_draw((char const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_draw", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_fl_draw__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    PyObject *retobj = _wrap_fl_draw__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_2:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_fl_draw__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_fl_draw__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 6) && (argc <= 9)) {
    int _v = 0;
    if (argc > 6) {
      {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Fl_Image, 0);
        _v = SWIG_CheckState(res);
      }
      if (!_v) goto check_5;
      if (argc > 7) {
        {
          {
            int res = SWIG_AsVal_int(argv[7], NULL);
            _v = SWIG_CheckState(res);
          }
        }
        if (!_v) goto check_5;
      }
    }
    PyObject *retobj = _wrap_fl_draw__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_5:
  
  if ((argc >= 7) && (argc <= 10)) {
    PyObject *retobj = _wrap_fl_draw__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_draw'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_draw(char const *,int,int)\n"
    "    fl_draw(int,char const *,int,int)\n"
    "    fl_draw(char const *,int,int,int)\n"
    "    fl_draw(int,char const *,int,int,int)\n"
    "    fl_draw(char const *,int,int,int,int,Fl_Align,Fl_Image *,int,int)\n"
    "    fl_draw(char const *,int,int,int,int,Fl_Align,void (*)(char const *,int,int,int),Fl_Image *,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_frame__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_frame" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_frame" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_frame" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_frame" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_frame" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      fl_frame((char const *)arg1,arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_frame(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_frame", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_fl_frame__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_fl_frame__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_frame'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_frame(Fl_Boxtype)\n"
    "    fl_frame(char const *,int,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_frame2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_frame2", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_frame2" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_frame2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_frame2" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_frame2" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_frame2" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      fl_frame2((char const *)arg1,arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw_box(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  Fl_Color arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_draw_box", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_draw_box" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = (Fl_Boxtype)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw_box" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw_box" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw_box" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_draw_box" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_draw_box" "', argument " "6"" of type '" "Fl_Color""'");
  } 
  arg6 = (Fl_Color)(val6);
  {
    try {
      fl_draw_box(arg1,arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw_box_focus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  Fl_Color arg6 ;
  Fl_Color arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_draw_box_focus", 7, 7, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_draw_box_focus" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = (Fl_Boxtype)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw_box_focus" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw_box_focus" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw_box_focus" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_draw_box_focus" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_draw_box_focus" "', argument " "6"" of type '" "Fl_Color""'");
  } 
  arg6 = (Fl_Color)(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fl_draw_box_focus" "', argument " "7"" of type '" "Fl_Color""'");
  } 
  arg7 = (Fl_Color)(val7);
  {
    try {
      fl_draw_box_focus(arg1,arg2,arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw_arrow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Rect arg1 ;
  Fl_Arrow_Type arg2 ;
  Fl_Orientation arg3 ;
  Fl_Color arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_draw_arrow", 4, 4, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Rect,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_draw_arrow" "', argument " "1"" of type '" "Fl_Rect""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_draw_arrow" "', argument " "1"" of type '" "Fl_Rect""'");
    } else {
      Fl_Rect * temp = (Fl_Rect *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw_arrow" "', argument " "2"" of type '" "Fl_Arrow_Type""'");
  } 
  arg2 = (Fl_Arrow_Type)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw_arrow" "', argument " "3"" of type '" "Fl_Orientation""'");
  } 
  arg3 = (Fl_Orientation)(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw_arrow" "', argument " "4"" of type '" "Fl_Color""'");
  } 
  arg4 = (Fl_Color)(val4);
  {
    try {
      fl_draw_arrow(SWIG_STD_MOVE(arg1),arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw_circle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  Fl_Color arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_draw_circle", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_draw_circle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw_circle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw_circle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw_circle" "', argument " "4"" of type '" "Fl_Color""'");
  } 
  arg4 = (Fl_Color)(val4);
  {
    try {
      fl_draw_circle(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw_radio(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  Fl_Color arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_draw_radio", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_draw_radio" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw_radio" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw_radio" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw_radio" "', argument " "4"" of type '" "Fl_Color""'");
  } 
  arg4 = (Fl_Color)(val4);
  {
    try {
      fl_draw_radio(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw_image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uchar *arg1 = (uchar *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 = (int) 3 ;
  int arg7 = (int) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_draw_image", 5, 7, swig_obj)) SWIG_fail;
  {
    /* Check if the input support the buffer protocol */
    Py_buffer view;
    const void * buffer;
    int failure = PyObject_GetBuffer(swig_obj[0], &view, PyBUF_CONTIG_RO);
    if (!failure) {
      // work with array object
      buffer = view.buf;
      PyBuffer_Release(&view);
      arg1 = (uchar *) buffer;
    } else {
      // work with list object
      // clear the error from PyObject_GetBuffer
      PyErr_Clear();
      buffer=0;
      /* Check if is a list */
      if (PyList_Check(swig_obj[0])) {
        Py_ssize_t size = PyList_Size(swig_obj[0]);
        int i = 0;
        arg1 = (uchar *) malloc((size+1)*sizeof(char));
        for (i = 0; i < size; i++) {
          PyObject *o = 	PyList_GetItem(swig_obj[0],i);
          if (PyInt_Check(o))
          arg1[i] = (char)PyInt_AsLong(o);
          else {
            PyErr_SetString(PyExc_TypeError,"list must contain ints");
            free(arg1);
            return NULL;
          }
        }
        arg1[i] = 0;
      } else {
        PyErr_SetString(PyExc_TypeError,"not a list or does not support single-segment readable buffer interface");
        return NULL;
      }
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw_image" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw_image" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw_image" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_draw_image" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_draw_image" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fl_draw_image" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  {
    try {
      fl_draw_image((unsigned char const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw_image_mono(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uchar *arg1 = (uchar *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 = (int) 1 ;
  int arg7 = (int) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_draw_image_mono", 5, 7, swig_obj)) SWIG_fail;
  {
    /* Check if the input support the buffer protocol */
    Py_buffer view;
    const void * buffer;
    int failure = PyObject_GetBuffer(swig_obj[0], &view, PyBUF_CONTIG_RO);
    if (!failure) {
      // work with array object
      buffer = view.buf;
      PyBuffer_Release(&view);
      arg1 = (uchar *) buffer;
    } else {
      // work with list object
      // clear the error from PyObject_GetBuffer
      PyErr_Clear();
      buffer=0;
      /* Check if is a list */
      if (PyList_Check(swig_obj[0])) {
        Py_ssize_t size = PyList_Size(swig_obj[0]);
        int i = 0;
        arg1 = (uchar *) malloc((size+1)*sizeof(char));
        for (i = 0; i < size; i++) {
          PyObject *o = 	PyList_GetItem(swig_obj[0],i);
          if (PyInt_Check(o))
          arg1[i] = (char)PyInt_AsLong(o);
          else {
            PyErr_SetString(PyExc_TypeError,"list must contain ints");
            free(arg1);
            return NULL;
          }
        }
        arg1[i] = 0;
      } else {
        PyErr_SetString(PyExc_TypeError,"not a list or does not support single-segment readable buffer interface");
        return NULL;
      }
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw_image_mono" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw_image_mono" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw_image_mono" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_draw_image_mono" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_draw_image_mono" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fl_draw_image_mono" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  {
    try {
      fl_draw_image_mono((unsigned char const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_can_do_alpha_blending(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_can_do_alpha_blending", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (char)fl_can_do_alpha_blending(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new char(result)), SWIGTYPE_p_char, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_capture_window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Fl_RGB_Image *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_capture_window", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_capture_window" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_capture_window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_capture_window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_capture_window" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_capture_window" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      result = (Fl_RGB_Image *)fl_capture_window(arg1,arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw_pixmap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char **arg1 = (char **) 0 ;
  int arg2 ;
  int arg3 ;
  Fl_Color arg4 = (Fl_Color) FL_BACKGROUND_COLOR ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_draw_pixmap", 3, 4, swig_obj)) SWIG_fail;
  {
    // Check if is a list
    if (PyList_Check(swig_obj[0])) {
      Py_ssize_t size = PyList_Size(swig_obj[0]);
      int i = 0;
      arg1 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[0],i);
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        //arg1[i] = PyString_AsString(PyList_GetItem(swig_obj[0],i));
        //arg1[i] = SWIG_Python_str_AsChar(PyList_GetItem(swig_obj[0],i));
        arg1[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(swig_obj[0],i)));
        else {
          PyErr_SetString(PyExc_TypeError,"list must contain strings");
          free(arg1);
          return NULL;
        }
      }
      arg1[i] = 0;
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw_pixmap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw_pixmap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw_pixmap" "', argument " "4"" of type '" "Fl_Color""'");
    } 
    arg4 = (Fl_Color)(val4);
  }
  {
    try {
      result = (int)fl_draw_pixmap((char *const *)arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    free((char *) arg1);
  }
  return resultobj;
fail:
  {
    free((char *) arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_measure_pixmap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char **arg1 = (char **) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  int result;
  
  arg2 = &temp2;
  arg3 = &temp3;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    // Check if is a list
    if (PyList_Check(swig_obj[0])) {
      Py_ssize_t size = PyList_Size(swig_obj[0]);
      int i = 0;
      arg1 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[0],i);
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        //arg1[i] = PyString_AsString(PyList_GetItem(swig_obj[0],i));
        //arg1[i] = SWIG_Python_str_AsChar(PyList_GetItem(swig_obj[0],i));
        arg1[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(swig_obj[0],i)));
        else {
          PyErr_SetString(PyExc_TypeError,"list must contain strings");
          free(arg1);
          return NULL;
        }
      }
      arg1[i] = 0;
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  {
    try {
      result = (int)fl_measure_pixmap((char *const *)arg1,*arg2,*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 0);
  }
  {
    free((char *) arg1);
  }
  return resultobj;
fail:
  {
    free((char *) arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_scroll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void (*arg7)(void *,int,int,int,int) = (void (*)(void *,int,int,int,int)) 0 ;
  void *arg8 = (void *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int res8 ;
  PyObject *swig_obj[8] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_scroll", 8, 8, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_scroll" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_scroll" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_scroll" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_scroll" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_scroll" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_scroll" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[6], (void**)(&arg7), SWIGTYPE_p_f_p_void_int_int_int_int__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "fl_scroll" "', argument " "7"" of type '" "void (*)(void *,int,int,int,int)""'"); 
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7],SWIG_as_voidptrptr(&arg8), 0, 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "fl_scroll" "', argument " "8"" of type '" "void *""'"); 
  }
  {
    try {
      fl_scroll(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_shortcut_label__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_shortcut_label" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = (unsigned int)(val1);
  {
    try {
      result = (char *)fl_shortcut_label(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_shortcut_label__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  char **arg2 = (char **) 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_shortcut_label" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = (unsigned int)(val1);
  {
    // Check if is a list
    if (PyList_Check(swig_obj[1])) {
      Py_ssize_t size = PyList_Size(swig_obj[1]);
      int i = 0;
      arg2 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[1],i);
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        //arg2[i] = PyString_AsString(PyList_GetItem(swig_obj[1],i));
        //arg2[i] = SWIG_Python_str_AsChar(PyList_GetItem(swig_obj[1],i));
        arg2[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(swig_obj[1],i)));
        else {
          PyErr_SetString(PyExc_TypeError,"list must contain strings");
          free(arg2);
          return NULL;
        }
      }
      arg2[i] = 0;
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  {
    try {
      result = (char *)fl_shortcut_label(arg1,(char const **)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    free((char *) arg2);
  }
  return resultobj;
fail:
  {
    free((char *) arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_shortcut_label(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_shortcut_label", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_fl_shortcut_label__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_fl_shortcut_label__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_shortcut_label'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_shortcut_label(unsigned int)\n"
    "    fl_shortcut_label(unsigned int,char const **)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_old_shortcut(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_old_shortcut" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (unsigned int)fl_old_shortcut((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_overlay_rect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_overlay_rect", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_overlay_rect" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_overlay_rect" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_overlay_rect" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_overlay_rect" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      fl_overlay_rect(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_overlay_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_overlay_clear", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_overlay_clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_cursor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Cursor arg1 ;
  int val1 ;
  int ecode1 = 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 '" "fl_cursor" "', argument " "1"" of type '" "Fl_Cursor""'");
  } 
  arg1 = (Fl_Cursor)(val1);
  {
    try {
      fl_cursor(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_cursor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Cursor arg1 ;
  Fl_Color arg2 ;
  Fl_Color arg3 = (Fl_Color) FL_WHITE ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_cursor" "', argument " "1"" of type '" "Fl_Cursor""'");
  } 
  arg1 = (Fl_Cursor)(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_cursor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_cursor" "', argument " "3"" of type '" "Fl_Color""'");
    } 
    arg3 = (Fl_Color)(val3);
  }
  {
    try {
      fl_cursor(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_cursor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_cursor", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_fl_cursor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 2) && (argc <= 3)) {
    PyObject *retobj = _wrap_fl_cursor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_cursor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_cursor(Fl_Cursor)\n"
    "    fl_cursor(Fl_Cursor,Fl_Color,Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_expand_text(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  double arg4 ;
  int *arg5 = 0 ;
  double *arg6 = 0 ;
  int arg7 ;
  int arg8 = (int) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int temp5 ;
  int res5 = SWIG_TMPOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject *swig_obj[7] ;
  char *result = 0 ;
  
  arg5 = &temp5;
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_expand_text", 6, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_expand_text" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_expand_text" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_expand_text" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_expand_text" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  res6 = SWIG_ConvertPtr(swig_obj[4], &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "fl_expand_text" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_expand_text" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = (double *)(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fl_expand_text" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = (int)(val7);
  if (swig_obj[6]) {
    ecode8 = SWIG_AsVal_int(swig_obj[6], &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "fl_expand_text" "', argument " "8"" of type '" "int""'");
    } 
    arg8 = (int)(val8);
  }
  {
    try {
      result = (char *)fl_expand_text((char const *)arg1,arg2,arg3,arg4,*arg5,*arg6,arg7,arg8); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 0);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_set_status(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_set_status", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_set_status" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_set_status" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_set_status" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_set_status" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      fl_set_status(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_set_spot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  Fl_Window *arg7 = (Fl_Window *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_set_spot", 6, 7, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_set_spot" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_set_spot" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_set_spot" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_set_spot" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_set_spot" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_set_spot" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  if (swig_obj[6]) {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_Fl_Window, 0 |  0 );
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "fl_set_spot" "', argument " "7"" of type '" "Fl_Window *""'"); 
    }
    arg7 = (Fl_Window *)(argp7);
  }
  {
    try {
      fl_set_spot(arg1,arg2,arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_reset_spot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_reset_spot", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_reset_spot(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw_symbol(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  Fl_Color arg6 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_draw_symbol", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_draw_symbol" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw_symbol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw_symbol" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw_symbol" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_draw_symbol" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_draw_symbol" "', argument " "6"" of type '" "Fl_Color""'");
  } 
  arg6 = (Fl_Color)(val6);
  {
    try {
      result = (int)fl_draw_symbol((char const *)arg1,arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_add_symbol(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  void (*arg2)(Fl_Color) = (void (*)(Fl_Color)) 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_add_symbol", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_add_symbol" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_unsigned_int__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "fl_add_symbol" "', argument " "2"" of type '" "void (*)(Fl_Color)""'"); 
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_add_symbol" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)fl_add_symbol((char const *)arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_measure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int arg4 = (int) 1 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[2] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_measure", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_measure" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  if (swig_obj[1]) {
    ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_measure" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  {
    try {
      fl_measure((char const *)arg1,*arg2,*arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Input__resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__resize" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Input__resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Input__resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Input__resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Input_::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Input_(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Input_ *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Input_", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Input_" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Input_" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Input_" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Input_" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Input_" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Input_ *)new SwigDirector_Fl_Input_(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
        SWIG_fail;
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Input_, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Input_(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Input_" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  char *arg2 = (char *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__value" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Input__value" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)(arg1)->value((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  char *arg2 = (char *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__value" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Input__value" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Input__value" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)(arg1)->value((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__value" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)(arg1)->value(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__value__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__value" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__value" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      result = (int)(arg1)->value(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__static_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  char *arg2 = (char *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__static_value" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Input__static_value" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)(arg1)->static_value((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__static_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  char *arg2 = (char *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__static_value" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Input__static_value" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Input__static_value" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)(arg1)->static_value((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__static_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input__static_value", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input__static_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Input__static_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input__static_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_::static_value(char const *)\n"
    "    Fl_Input_::static_value(char const *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input__value__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__value" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (char *)((Fl_Input_ const *)arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input__value", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input__value__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_Fl_Input__value__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    return _wrap_Fl_Input__value__SWIG_3(self, argc, argv);
  }
check_3:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input__value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Input__value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input__value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_::value(char const *)\n"
    "    Fl_Input_::value(char const *,int)\n"
    "    Fl_Input_::value(int)\n"
    "    Fl_Input_::value(double)\n"
    "    Fl_Input_::value() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input__ivalue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__ivalue" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (int)((Fl_Input_ const *)arg1)->ivalue(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__dvalue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__dvalue" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (double)((Fl_Input_ const *)arg1)->dvalue(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Input__index", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__index" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__index" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (unsigned int)((Fl_Input_ const *)arg1)->index(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__size" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (int)((Fl_Input_ const *)arg1)->size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__size" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Input__size" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->size(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input__size", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input__size__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Input__size__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input__size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_::size() const\n"
    "    Fl_Input_::size(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input__maximum_size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__maximum_size" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (int)((Fl_Input_ const *)arg1)->maximum_size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__maximum_size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__maximum_size" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__maximum_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->maximum_size(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__maximum_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input__maximum_size", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input__maximum_size__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input__maximum_size__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input__maximum_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_::maximum_size() const\n"
    "    Fl_Input_::maximum_size(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input__insert_position__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__insert_position" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (int)((Fl_Input_ const *)arg1)->insert_position(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__mark__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__mark" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (int)((Fl_Input_ const *)arg1)->mark(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__insert_position__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__insert_position" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__insert_position" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Input__insert_position" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)(arg1)->insert_position(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__insert_position__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__insert_position" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__insert_position" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)(arg1)->insert_position(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__insert_position(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input__insert_position", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input__insert_position__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input__insert_position__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Input__insert_position__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input__insert_position'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_::insert_position() const\n"
    "    Fl_Input_::insert_position(int,int)\n"
    "    Fl_Input_::insert_position(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input__mark__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__mark" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__mark" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)(arg1)->mark(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__mark(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input__mark", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input__mark__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input__mark__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input__mark'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_::mark() const\n"
    "    Fl_Input_::mark(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input__replace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  int arg2 ;
  int arg3 ;
  char *arg4 = (char *) 0 ;
  int arg5 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Input__replace", 4, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__replace" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__replace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Input__replace" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Input__replace" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = (char *)(buf4);
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Input__replace" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = (int)(val5);
  }
  {
    try {
      result = (int)(arg1)->replace(arg2,arg3,(char const *)arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__cut__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__cut" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (int)(arg1)->cut(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__cut__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__cut" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__cut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)(arg1)->cut(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__cut__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__cut" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__cut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Input__cut" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)(arg1)->cut(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__cut(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input__cut", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input__cut__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input__cut__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Input__cut__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input__cut'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_::cut()\n"
    "    Fl_Input_::cut(int)\n"
    "    Fl_Input_::cut(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input__insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Input__insert", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__insert" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Input__insert" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Input__insert" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->insert((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 = (int) 0 ;
  char arg4 = (char) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  char val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Input__append", 2, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__append" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Input__append" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Input__append" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_char(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Input__append" "', argument " "4"" of type '" "char""'");
    } 
    arg4 = (char)(val4);
  }
  {
    try {
      result = (int)(arg1)->append((char const *)arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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, "Fl_Input__copy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__copy" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)(arg1)->copy(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__undo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__undo" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (int)(arg1)->undo(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__can_undo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__can_undo" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (bool)((Fl_Input_ const *)arg1)->can_undo(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__redo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__redo" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (int)(arg1)->redo(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__can_redo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__can_redo" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (bool)((Fl_Input_ const *)arg1)->can_redo(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__copy_cuts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__copy_cuts" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (int)(arg1)->copy_cuts(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__shortcut__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__shortcut" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (int)((Fl_Input_ const *)arg1)->shortcut(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__shortcut__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__shortcut" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__shortcut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->shortcut(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__shortcut(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input__shortcut", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input__shortcut__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input__shortcut__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input__shortcut'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_::shortcut() const\n"
    "    Fl_Input_::shortcut(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input__textfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__textfont" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Input_ const *)arg1)->textfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__textfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  Fl_Font 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__textfont" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->textfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__textfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input__textfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input__textfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input__textfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input__textfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_::textfont() const\n"
    "    Fl_Input_::textfont(Fl_Font)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input__textsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__textsize" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Input_ const *)arg1)->textsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__textsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  Fl_Fontsize 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__textsize" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->textsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__textsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input__textsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input__textsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input__textsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input__textsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_::textsize() const\n"
    "    Fl_Input_::textsize(Fl_Fontsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input__textcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__textcolor" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Input_ const *)arg1)->textcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__textcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__textcolor" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->textcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__textcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input__textcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input__textcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input__textcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input__textcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_::textcolor() const\n"
    "    Fl_Input_::textcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input__cursor_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__cursor_color" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Input_ const *)arg1)->cursor_color(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__cursor_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__cursor_color" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__cursor_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->cursor_color(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__cursor_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input__cursor_color", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input__cursor_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input__cursor_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input__cursor_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_::cursor_color() const\n"
    "    Fl_Input_::cursor_color(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input__input_type__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__input_type" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (int)((Fl_Input_ const *)arg1)->input_type(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__input_type__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__input_type" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__input_type" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->input_type(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__input_type(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input__input_type", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input__input_type__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input__input_type__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input__input_type'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_::input_type() const\n"
    "    Fl_Input_::input_type(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input__readonly__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__readonly" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (int)((Fl_Input_ const *)arg1)->readonly(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__readonly__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__readonly" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__readonly" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->readonly(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__readonly(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input__readonly", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input__readonly__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input__readonly__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input__readonly'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_::readonly() const\n"
    "    Fl_Input_::readonly(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input__wrap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__wrap" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (int)((Fl_Input_ const *)arg1)->wrap(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__wrap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__wrap" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__wrap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->wrap(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__wrap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input__wrap", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input__wrap__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input__wrap__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input__wrap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_::wrap() const\n"
    "    Fl_Input_::wrap(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input__tab_nav__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__tab_nav" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__tab_nav" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->tab_nav(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__tab_nav__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__tab_nav" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    try {
      result = (int)((Fl_Input_ const *)arg1)->tab_nav(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__tab_nav(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input__tab_nav", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input__tab_nav__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input__tab_nav__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input__tab_nav'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_::tab_nav(int)\n"
    "    Fl_Input_::tab_nav() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input__init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 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, "Fl_Input__init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__init_type" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Input__init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Input__init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Input_(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Input_" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = (Fl_Input_ *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Input_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input *arg1 = (Fl_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Input *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_draw" "', argument " "1"" of type '" "Fl_Input *""'"); 
  }
  arg1 = (Fl_Input *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Input *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input *arg1 = (Fl_Input *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Input_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_handle" "', argument " "1"" of type '" "Fl_Input *""'"); 
  }
  arg1 = (Fl_Input *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Input::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Input *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Input", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Input" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Input" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Input" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Input" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Input" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Input *)new SwigDirector_Fl_Input(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Input *)new Fl_Input(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Input, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input *arg1 = (Fl_Input *) 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, "Fl_Input_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_init_type" "', argument " "1"" of type '" "Fl_Input *""'"); 
  }
  arg1 = (Fl_Input *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Input_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Input_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input *arg1 = (Fl_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Input" "', argument " "1"" of type '" "Fl_Input *""'"); 
  }
  arg1 = (Fl_Input *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input *arg1 = (Fl_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Input" "', argument " "1"" of type '" "Fl_Input *""'"); 
  }
  arg1 = (Fl_Input *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_File_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_File_Input *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_File_Input", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_File_Input" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_File_Input" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_File_Input" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_File_Input" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_File_Input" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_File_Input *)new SwigDirector_Fl_File_Input(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_File_Input *)new Fl_File_Input(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_File_Input, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Input *arg1 = (Fl_File_Input *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_File_Input_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Input_handle" "', argument " "1"" of type '" "Fl_File_Input *""'"); 
  }
  arg1 = (Fl_File_Input *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Input_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_File_Input::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Input *arg1 = (Fl_File_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Input *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Input_draw" "', argument " "1"" of type '" "Fl_File_Input *""'"); 
  }
  arg1 = (Fl_File_Input *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Input *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_down_box__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Input *arg1 = (Fl_File_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Boxtype result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Input_down_box" "', argument " "1"" of type '" "Fl_File_Input const *""'"); 
  }
  arg1 = (Fl_File_Input *)(argp1);
  {
    try {
      result = (Fl_Boxtype)((Fl_File_Input const *)arg1)->down_box(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_down_box__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Input *arg1 = (Fl_File_Input *) 0 ;
  Fl_Boxtype 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_Fl_File_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Input_down_box" "', argument " "1"" of type '" "Fl_File_Input *""'"); 
  }
  arg1 = (Fl_File_Input *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Input_down_box" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = (Fl_Boxtype)(val2);
  {
    try {
      (arg1)->down_box(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_down_box(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Input_down_box", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Input_down_box__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Input_down_box__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Input_down_box'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Input::down_box() const\n"
    "    Fl_File_Input::down_box(Fl_Boxtype)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_errorcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Input *arg1 = (Fl_File_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Input_errorcolor" "', argument " "1"" of type '" "Fl_File_Input const *""'"); 
  }
  arg1 = (Fl_File_Input *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_File_Input const *)arg1)->errorcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_errorcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Input *arg1 = (Fl_File_Input *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Input_errorcolor" "', argument " "1"" of type '" "Fl_File_Input *""'"); 
  }
  arg1 = (Fl_File_Input *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Input_errorcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->errorcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_errorcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Input_errorcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Input_errorcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Input_errorcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Input_errorcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Input::errorcolor() const\n"
    "    Fl_File_Input::errorcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Input *arg1 = (Fl_File_Input *) 0 ;
  char *arg2 = (char *) 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_Fl_File_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Input_value" "', argument " "1"" of type '" "Fl_File_Input *""'"); 
  }
  arg1 = (Fl_File_Input *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_File_Input_value" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)(arg1)->value((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Input *arg1 = (Fl_File_Input *) 0 ;
  char *arg2 = (char *) 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_Fl_File_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Input_value" "', argument " "1"" of type '" "Fl_File_Input *""'"); 
  }
  arg1 = (Fl_File_Input *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_File_Input_value" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_File_Input_value" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)(arg1)->value((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_File_Input *arg1 = (Fl_File_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Input_value" "', argument " "1"" of type '" "Fl_File_Input *""'"); 
  }
  arg1 = (Fl_File_Input *)(argp1);
  {
    try {
      result = (char *)(arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_File_Input_value", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_File_Input_value__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_File_Input_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_File_Input_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_File_Input_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_File_Input::value(char const *)\n"
    "    Fl_File_Input::value(char const *,int)\n"
    "    Fl_File_Input::value()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Input *arg1 = (Fl_File_Input *) 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, "Fl_File_Input_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_File_Input_init_type" "', argument " "1"" of type '" "Fl_File_Input *""'"); 
  }
  arg1 = (Fl_File_Input *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_File_Input_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_File_Input_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_File_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Input *arg1 = (Fl_File_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Input, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_File_Input" "', argument " "1"" of type '" "Fl_File_Input *""'"); 
  }
  arg1 = (Fl_File_Input *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_File_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Input *arg1 = (Fl_File_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_File_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_File_Input" "', argument " "1"" of type '" "Fl_File_Input *""'"); 
  }
  arg1 = (Fl_File_Input *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Fill_Dial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) NULL ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Fill_Dial *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Fill_Dial", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Fill_Dial" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Fill_Dial" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Fill_Dial" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Fill_Dial" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Fill_Dial" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Fill_Dial *)new SwigDirector_Fl_Fill_Dial(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Fill_Dial *)new Fl_Fill_Dial(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Fill_Dial, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Fill_Dial_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Fill_Dial *arg1 = (Fl_Fill_Dial *) 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, "Fl_Fill_Dial_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Fill_Dial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Fill_Dial_init_type" "', argument " "1"" of type '" "Fl_Fill_Dial *""'"); 
  }
  arg1 = (Fl_Fill_Dial *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Fill_Dial_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Fill_Dial_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Fill_Dial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Fill_Dial *arg1 = (Fl_Fill_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Fill_Dial, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Fill_Dial" "', argument " "1"" of type '" "Fl_Fill_Dial *""'"); 
  }
  arg1 = (Fl_Fill_Dial *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Fill_Dial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Fill_Dial *arg1 = (Fl_Fill_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Fill_Dial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Fill_Dial" "', argument " "1"" of type '" "Fl_Fill_Dial *""'"); 
  }
  arg1 = (Fl_Fill_Dial *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Fill_Dial_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Fill_Dial *arg1 = (Fl_Fill_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Fill_Dial *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Fill_Dial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Fill_Dial_draw" "', argument " "1"" of type '" "Fl_Fill_Dial *""'"); 
  }
  arg1 = (Fl_Fill_Dial *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Fill_Dial *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Slider_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Slider *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Slider_draw" "', argument " "1"" of type '" "Fl_Slider *""'"); 
  }
  arg1 = (Fl_Slider *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Slider *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Slider_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Slider_handle" "', argument " "1"" of type '" "Fl_Slider *""'"); 
  }
  arg1 = (Fl_Slider *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Slider_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Slider::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Slider__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  Fl_Slider *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Slider" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Slider" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Slider" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Slider" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Slider" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Slider *)new SwigDirector_Fl_Slider(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Slider *)new Fl_Slider(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Slider, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Slider__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  uchar arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  char *arg7 = (char *) 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int res7 ;
  char *buf7 = 0 ;
  int alloc7 = 0 ;
  Fl_Slider *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Slider" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Slider" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Slider" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Slider" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fl_Slider" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  res7 = SWIG_AsCharPtrAndSize(swig_obj[6], &buf7, NULL, &alloc7);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Fl_Slider" "', argument " "7"" of type '" "char const *""'");
  }
  arg7 = (char *)(buf7);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Slider *)new SwigDirector_Fl_Slider(arg1,arg2,arg3,arg4,arg5,arg6,(char const *)arg7); 
      } else {
        result = (Fl_Slider *)new Fl_Slider(arg2,arg3,arg4,arg5,arg6,(char const *)arg7); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Slider, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Slider(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_Slider", 0, 7, argv))) SWIG_fail;
  --argc;
  if ((argc >= 5) && (argc <= 6)) {
    PyObject *retobj = _wrap_new_Fl_Slider__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_new_Fl_Slider__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_Slider'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Slider::Fl_Slider(int,int,int,int,char const *)\n"
    "    Fl_Slider::Fl_Slider(PyObject *,uchar,int,int,int,int,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_scrollvalue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Slider_scrollvalue", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Slider_scrollvalue" "', argument " "1"" of type '" "Fl_Slider *""'"); 
  }
  arg1 = (Fl_Slider *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Slider_scrollvalue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Slider_scrollvalue" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Slider_scrollvalue" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Slider_scrollvalue" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      result = (int)(arg1)->scrollvalue(arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_bounds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Slider_bounds", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Slider_bounds" "', argument " "1"" of type '" "Fl_Slider *""'"); 
  }
  arg1 = (Fl_Slider *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Slider_bounds" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Slider_bounds" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  {
    try {
      (arg1)->bounds(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_slider_size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Slider_slider_size" "', argument " "1"" of type '" "Fl_Slider const *""'"); 
  }
  arg1 = (Fl_Slider *)(argp1);
  {
    try {
      result = (float)((Fl_Slider const *)arg1)->slider_size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_float((float)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_slider_size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 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_Fl_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Slider_slider_size" "', argument " "1"" of type '" "Fl_Slider *""'"); 
  }
  arg1 = (Fl_Slider *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Slider_slider_size" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      (arg1)->slider_size(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_slider_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Slider_slider_size", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Slider_slider_size__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Slider_slider_size__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Slider_slider_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Slider::slider_size() const\n"
    "    Fl_Slider::slider_size(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_slider__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Boxtype result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Slider_slider" "', argument " "1"" of type '" "Fl_Slider const *""'"); 
  }
  arg1 = (Fl_Slider *)(argp1);
  {
    try {
      result = (Fl_Boxtype)((Fl_Slider const *)arg1)->slider(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_slider__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  Fl_Boxtype 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_Fl_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Slider_slider" "', argument " "1"" of type '" "Fl_Slider *""'"); 
  }
  arg1 = (Fl_Slider *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Slider_slider" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = (Fl_Boxtype)(val2);
  {
    try {
      (arg1)->slider(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_slider(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Slider_slider", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Slider_slider__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Slider_slider__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Slider_slider'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Slider::slider() const\n"
    "    Fl_Slider::slider(Fl_Boxtype)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_scale__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Slider::Scale_Type result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Slider_scale" "', argument " "1"" of type '" "Fl_Slider const *""'"); 
  }
  arg1 = (Fl_Slider *)(argp1);
  {
    try {
      result = (Fl_Slider::Scale_Type)((Fl_Slider const *)arg1)->scale(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_scale__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  Fl_Slider::Scale_Type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Slider_scale" "', argument " "1"" of type '" "Fl_Slider *""'"); 
  }
  arg1 = (Fl_Slider *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Slider_scale" "', argument " "2"" of type '" "Fl_Slider::Scale_Type""'");
  } 
  arg2 = (Fl_Slider::Scale_Type)(val2);
  {
    try {
      (arg1)->scale(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_scale(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Slider_scale", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Slider_scale__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Slider_scale__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Slider_scale'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Slider::scale() const\n"
    "    Fl_Slider::scale(Fl_Slider::Scale_Type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_ticks__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Slider_ticks" "', argument " "1"" of type '" "Fl_Slider const *""'"); 
  }
  arg1 = (Fl_Slider *)(argp1);
  {
    try {
      result = (uchar)((Fl_Slider const *)arg1)->ticks(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_num_ticks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uchar result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Slider_num_ticks" "', argument " "1"" of type '" "Fl_Slider const *""'"); 
  }
  arg1 = (Fl_Slider *)(argp1);
  {
    try {
      result = (uchar)((Fl_Slider const *)arg1)->num_ticks(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_ticks__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  uchar arg2 ;
  uchar arg3 = (uchar) 11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Slider_ticks" "', argument " "1"" of type '" "Fl_Slider *""'"); 
  }
  arg1 = (Fl_Slider *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Slider_ticks" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Slider_ticks" "', argument " "3"" of type '" "uchar""'");
    } 
    arg3 = (uchar)(val3);
  }
  {
    try {
      (arg1)->ticks(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_ticks(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Slider_ticks", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Slider_ticks__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 2) && (argc <= 3)) {
    PyObject *retobj = _wrap_Fl_Slider_ticks__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Slider_ticks'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Slider::ticks() const\n"
    "    Fl_Slider::ticks(uchar,uchar)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 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, "Fl_Slider_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Slider_init_type" "', argument " "1"" of type '" "Fl_Slider *""'"); 
  }
  arg1 = (Fl_Slider *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Slider_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Slider_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Slider, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Slider" "', argument " "1"" of type '" "Fl_Slider *""'"); 
  }
  arg1 = (Fl_Slider *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Slider" "', argument " "1"" of type '" "Fl_Slider *""'"); 
  }
  arg1 = (Fl_Slider *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Fill_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Fill_Slider *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Fill_Slider", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Fill_Slider" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Fill_Slider" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Fill_Slider" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Fill_Slider" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Fill_Slider" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Fill_Slider *)new SwigDirector_Fl_Fill_Slider(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Fill_Slider *)new Fl_Fill_Slider(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Fill_Slider, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Fill_Slider_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Fill_Slider *arg1 = (Fl_Fill_Slider *) 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, "Fl_Fill_Slider_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Fill_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Fill_Slider_init_type" "', argument " "1"" of type '" "Fl_Fill_Slider *""'"); 
  }
  arg1 = (Fl_Fill_Slider *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Fill_Slider_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Fill_Slider_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Fill_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Fill_Slider *arg1 = (Fl_Fill_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Fill_Slider, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Fill_Slider" "', argument " "1"" of type '" "Fl_Fill_Slider *""'"); 
  }
  arg1 = (Fl_Fill_Slider *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Fill_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Fill_Slider *arg1 = (Fl_Fill_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Fill_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Fill_Slider" "', argument " "1"" of type '" "Fl_Fill_Slider *""'"); 
  }
  arg1 = (Fl_Fill_Slider *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Fill_Slider_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Fill_Slider *arg1 = (Fl_Fill_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Fill_Slider *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Fill_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Fill_Slider_draw" "', argument " "1"" of type '" "Fl_Fill_Slider *""'"); 
  }
  arg1 = (Fl_Fill_Slider *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Fill_Slider *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Flex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  Fl_Flex *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Flex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Flex" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Flex" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Flex" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Flex" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Flex *)new SwigDirector_Fl_Flex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Flex *)new Fl_Flex(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Flex, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Flex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int val2 ;
  int ecode2 = 0 ;
  Fl_Flex *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Flex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Flex *)new SwigDirector_Fl_Flex(arg1,arg2); 
      } else {
        result = (Fl_Flex *)new Fl_Flex(arg2); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Flex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Flex__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Fl_Flex *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Flex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Flex" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Flex" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Flex *)new SwigDirector_Fl_Flex(arg1,arg2,arg3,arg4); 
      } else {
        result = (Fl_Flex *)new Fl_Flex(arg2,arg3,arg4); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Flex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Flex__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Fl_Flex *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Flex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Flex" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Flex" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Flex" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fl_Flex" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Flex *)new SwigDirector_Fl_Flex(arg1,arg2,arg3,arg4,arg5,arg6); 
      } else {
        result = (Fl_Flex *)new Fl_Flex(arg2,arg3,arg4,arg5,arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Flex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Flex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_Flex", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Fl_Flex__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_Fl_Flex__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 5) && (argc <= 6)) {
    int _v = 0;
    if (argc > 5) {
      {
        int res = SWIG_AsCharPtrAndSize(argv[5], 0, NULL, 0);
        _v = SWIG_CheckState(res);
      }
      if (!_v) goto check_3;
    }
    return _wrap_new_Fl_Flex__SWIG_0(self, argc, argv);
  }
check_3:
  
  if (argc == 6) {
    PyObject *retobj = _wrap_new_Fl_Flex__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_Flex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Flex::Fl_Flex(int,int,int,int,char const *)\n"
    "    Fl_Flex::Fl_Flex(int)\n"
    "    Fl_Flex::Fl_Flex(int,int,int)\n"
    "    Fl_Flex::Fl_Flex(PyObject *,int,int,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Flex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Flex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Flex" "', argument " "1"" of type '" "Fl_Flex *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_end" "', argument " "1"" of type '" "Fl_Flex *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Flex::end();
        } else {
          (arg1)->end();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Flex_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_resize" "', argument " "1"" of type '" "Fl_Flex *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Flex_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Flex_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Flex_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Flex_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Flex::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_fixed__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 0 ;
  Fl_Widget *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_fixed" "', argument " "1"" of type '" "Fl_Flex *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Widget,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Flex_fixed" "', argument " "2"" of type '" "Fl_Widget &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Flex_fixed" "', argument " "2"" of type '" "Fl_Widget &""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Flex_fixed" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->fixed(*arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_fixed__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_fixed" "', argument " "1"" of type '" "Fl_Flex *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Flex_fixed" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Flex_fixed" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->fixed(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_fixed__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_fixed" "', argument " "1"" of type '" "Fl_Flex const *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Flex_fixed" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  {
    try {
      result = (int)((Fl_Flex const *)arg1)->fixed(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_fixed(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Flex_fixed", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Flex_fixed__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Widget, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    PyObject *retobj = _wrap_Fl_Flex_fixed__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Flex_fixed__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Flex_fixed'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Flex::fixed(Fl_Widget &,int)\n"
    "    Fl_Flex::fixed(Fl_Widget *,int)\n"
    "    Fl_Flex::fixed(Fl_Widget *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_alloc_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Flex *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Flex_alloc_size", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_alloc_size" "', argument " "1"" of type '" "Fl_Flex const *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Flex_alloc_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("alloc_size"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member alloc_size");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Flex *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Flex const *)darg)->alloc_sizeSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Flex const *)darg)->alloc_size(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Flex *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_draw" "', argument " "1"" of type '" "Fl_Flex *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Flex *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_need_layout__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 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_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_need_layout" "', argument " "1"" of type '" "Fl_Flex *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Flex_need_layout" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->need_layout(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_need_layout__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_need_layout" "', argument " "1"" of type '" "Fl_Flex const *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  {
    try {
      result = (bool)((Fl_Flex const *)arg1)->need_layout(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_need_layout(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Flex_need_layout", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Flex_need_layout__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Flex_need_layout__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Flex_need_layout'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Flex::need_layout(int)\n"
    "    Fl_Flex::need_layout() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_margin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 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_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_margin" "', argument " "1"" of type '" "Fl_Flex const *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  {
    try {
      result = (int)((Fl_Flex const *)arg1)->margin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_margin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  int *arg4 = (int *) 0 ;
  int *arg5 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_margin" "', argument " "1"" of type '" "Fl_Flex const *""'"); 
  }
  arg1 = (Fl_Flex *)(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 '" "Fl_Flex_margin" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (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 '" "Fl_Flex_margin" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Flex_margin" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Fl_Flex_margin" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  {
    try {
      result = (int)((Fl_Flex const *)arg1)->margin(arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_margin__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 0 ;
  int arg2 ;
  int arg3 = (int) -1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_margin" "', argument " "1"" of type '" "Fl_Flex *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Flex_margin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Flex_margin" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      (arg1)->margin(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_margin__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_margin" "', argument " "1"" of type '" "Fl_Flex *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Flex_margin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Flex_margin" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Flex_margin" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Flex_margin" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      (arg1)->margin(arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_margin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Flex_margin", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Flex_margin__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 2) && (argc <= 3)) {
    PyObject *retobj = _wrap_Fl_Flex_margin__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_Fl_Flex_margin__SWIG_1(self, argc, argv);
  }
check_3:
  
  if (argc == 5) {
    PyObject *retobj = _wrap_Fl_Flex_margin__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Flex_margin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Flex::margin() const\n"
    "    Fl_Flex::margin(int *,int *,int *,int *) const\n"
    "    Fl_Flex::margin(int,int)\n"
    "    Fl_Flex::margin(int,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_gap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 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_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_gap" "', argument " "1"" of type '" "Fl_Flex const *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  {
    try {
      result = (int)((Fl_Flex const *)arg1)->gap(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_gap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 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_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_gap" "', argument " "1"" of type '" "Fl_Flex *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Flex_gap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->gap(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_gap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Flex_gap", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Flex_gap__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Flex_gap__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Flex_gap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Flex::gap() const\n"
    "    Fl_Flex::gap(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_horizontal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 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_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_horizontal" "', argument " "1"" of type '" "Fl_Flex const *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  {
    try {
      result = (int)((Fl_Flex const *)arg1)->horizontal(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_layout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_layout" "', argument " "1"" of type '" "Fl_Flex *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  {
    try {
      (arg1)->layout(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_spacing__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 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_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_spacing" "', argument " "1"" of type '" "Fl_Flex const *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  {
    try {
      result = (int)((Fl_Flex const *)arg1)->spacing(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_spacing__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 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_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_spacing" "', argument " "1"" of type '" "Fl_Flex *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Flex_spacing" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->spacing(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_spacing(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Flex_spacing", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Flex_spacing__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Flex_spacing__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Flex_spacing'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Flex::spacing() const\n"
    "    Fl_Flex::spacing(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Flex_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 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, "Fl_Flex_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Flex_init_type" "', argument " "1"" of type '" "Fl_Flex *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Flex_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Flex_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Flex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Flex *arg1 = (Fl_Flex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Flex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Flex" "', argument " "1"" of type '" "Fl_Flex *""'"); 
  }
  arg1 = (Fl_Flex *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Float_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Float_Input *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Float_Input", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Float_Input" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Float_Input" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Float_Input" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Float_Input" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Float_Input" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Float_Input *)new SwigDirector_Fl_Float_Input(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Float_Input *)new Fl_Float_Input(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Float_Input, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Float_Input_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Float_Input *arg1 = (Fl_Float_Input *) 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, "Fl_Float_Input_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Float_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Float_Input_init_type" "', argument " "1"" of type '" "Fl_Float_Input *""'"); 
  }
  arg1 = (Fl_Float_Input *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Float_Input_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Float_Input_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Float_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Float_Input *arg1 = (Fl_Float_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Float_Input, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Float_Input" "', argument " "1"" of type '" "Fl_Float_Input *""'"); 
  }
  arg1 = (Fl_Float_Input *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Float_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Float_Input *arg1 = (Fl_Float_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Float_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Float_Input" "', argument " "1"" of type '" "Fl_Float_Input *""'"); 
  }
  arg1 = (Fl_Float_Input *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Float_Input_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Float_Input *arg1 = (Fl_Float_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Float_Input *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Float_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Float_Input_draw" "', argument " "1"" of type '" "Fl_Float_Input *""'"); 
  }
  arg1 = (Fl_Float_Input *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Float_Input *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Pixmap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char **arg2 = (char **) 0 ;
  PyObject *swig_obj[2] ;
  Fl_Pixmap *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Pixmap", 2, 2, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  {
    /* Check if it is a list */
    if (PyList_Check(swig_obj[1])) {
      Py_ssize_t size = PyList_Size(swig_obj[1]);
      int i = 0;
      arg2 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[1],i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg2[i] = PyString_AsString(PyList_GetItem(swig_obj[1],i));
          //arg2[i] = SWIG_Python_str_AsChar(PyList_GetItem(swig_obj[1],i));
          arg2[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(swig_obj[1],i)));
        }
        else {
          PyErr_SetString(PyExc_TypeError,"list must contain strings");
          free(arg2);
          return NULL;
        }
        
      }
      arg2[i] = NULL;
      
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Pixmap *)new SwigDirector_Fl_Pixmap(arg1,(char const *const *)arg2); 
      } else {
        result = (Fl_Pixmap *)new Fl_Pixmap((char const *const *)arg2); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Pixmap, SWIG_POINTER_NEW |  0 );
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg2);
  }
  return resultobj;
fail:
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Pixmap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pixmap *arg1 = (Fl_Pixmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Pixmap, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Pixmap" "', argument " "1"" of type '" "Fl_Pixmap *""'"); 
  }
  arg1 = (Fl_Pixmap *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_copy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Pixmap *arg1 = (Fl_Pixmap *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Pixmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Pixmap_copy" "', argument " "1"" of type '" "Fl_Pixmap const *""'"); 
  }
  arg1 = (Fl_Pixmap *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Pixmap_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Pixmap_copy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Image *)((Fl_Pixmap const *)arg1)->Fl_Pixmap::copy(arg2,arg3);
        } else {
          result = (Fl_Image *)((Fl_Pixmap const *)arg1)->copy(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, SWIG_POINTER_OWN |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_copy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Pixmap *arg1 = (Fl_Pixmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Pixmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Pixmap_copy" "', argument " "1"" of type '" "Fl_Pixmap const *""'"); 
  }
  arg1 = (Fl_Pixmap *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Pixmap const *)arg1)->copy(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_copy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Pixmap_copy", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Pixmap_copy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Pixmap_copy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Pixmap_copy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Pixmap::copy(int,int) const\n"
    "    Fl_Pixmap::copy() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_color_average(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pixmap *arg1 = (Fl_Pixmap *) 0 ;
  Fl_Color arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Pixmap_color_average", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Pixmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Pixmap_color_average" "', argument " "1"" of type '" "Fl_Pixmap *""'"); 
  }
  arg1 = (Fl_Pixmap *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Pixmap_color_average" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Pixmap_color_average" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = (float)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Pixmap::color_average(arg2,arg3);
        } else {
          (arg1)->color_average(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_desaturate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pixmap *arg1 = (Fl_Pixmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Pixmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Pixmap_desaturate" "', argument " "1"" of type '" "Fl_Pixmap *""'"); 
  }
  arg1 = (Fl_Pixmap *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Pixmap::desaturate();
        } else {
          (arg1)->desaturate();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_draw__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Pixmap *arg1 = (Fl_Pixmap *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 = (int) 0 ;
  int arg7 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Pixmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Pixmap_draw" "', argument " "1"" of type '" "Fl_Pixmap *""'"); 
  }
  arg1 = (Fl_Pixmap *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Pixmap_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Pixmap_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Pixmap_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Pixmap_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Pixmap_draw" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Pixmap_draw" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Pixmap::draw(arg2,arg3,arg4,arg5,arg6,arg7);
        } else {
          (arg1)->draw(arg2,arg3,arg4,arg5,arg6,arg7);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_draw__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Pixmap *arg1 = (Fl_Pixmap *) 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_Fl_Pixmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Pixmap_draw" "', argument " "1"" of type '" "Fl_Pixmap *""'"); 
  }
  arg1 = (Fl_Pixmap *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Pixmap_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Pixmap_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->draw(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_draw(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Pixmap_draw", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Pixmap_draw__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 5) && (argc <= 7)) {
    PyObject *retobj = _wrap_Fl_Pixmap_draw__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Pixmap_draw'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Pixmap::draw(int,int,int,int,int,int)\n"
    "    Fl_Pixmap::draw(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_label__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Pixmap *arg1 = (Fl_Pixmap *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Pixmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Pixmap_label" "', argument " "1"" of type '" "Fl_Pixmap *""'"); 
  }
  arg1 = (Fl_Pixmap *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Pixmap_label" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Pixmap::label(arg2);
        } else {
          (arg1)->label(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_label__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Pixmap *arg1 = (Fl_Pixmap *) 0 ;
  Fl_Menu_Item *arg2 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Pixmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Pixmap_label" "', argument " "1"" of type '" "Fl_Pixmap *""'"); 
  }
  arg1 = (Fl_Pixmap *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Pixmap_label" "', argument " "2"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg2 = (Fl_Menu_Item *)(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Pixmap::label(arg2);
        } else {
          (arg1)->label(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_label(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Pixmap_label", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Widget, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Pixmap_label__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Pixmap_label__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Pixmap_label'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Pixmap::label(Fl_Widget *)\n"
    "    Fl_Pixmap::label(Fl_Menu_Item *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_uncache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pixmap *arg1 = (Fl_Pixmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Pixmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Pixmap_uncache" "', argument " "1"" of type '" "Fl_Pixmap *""'"); 
  }
  arg1 = (Fl_Pixmap *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Pixmap::uncache();
        } else {
          (arg1)->uncache();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_cache_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pixmap *arg1 = (Fl_Pixmap *) 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_Fl_Pixmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Pixmap_cache_w" "', argument " "1"" of type '" "Fl_Pixmap *""'"); 
  }
  arg1 = (Fl_Pixmap *)(argp1);
  {
    try {
      result = (int)(arg1)->cache_w(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_cache_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pixmap *arg1 = (Fl_Pixmap *) 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_Fl_Pixmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Pixmap_cache_h" "', argument " "1"" of type '" "Fl_Pixmap *""'"); 
  }
  arg1 = (Fl_Pixmap *)(argp1);
  {
    try {
      result = (int)(arg1)->cache_h(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Pixmap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pixmap *arg1 = (Fl_Pixmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Pixmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Pixmap" "', argument " "1"" of type '" "Fl_Pixmap *""'"); 
  }
  arg1 = (Fl_Pixmap *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Grid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Grid *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Grid", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Grid" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Grid" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Grid" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Grid" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Grid" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Grid *)new SwigDirector_Fl_Grid(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Grid *)new Fl_Grid(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Grid, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Grid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Grid" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_layout__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 = (int) -1 ;
  int arg5 = (int) -1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_layout" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_layout" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Grid_layout" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Grid_layout" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Grid_layout" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = (int)(val5);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Grid::layout(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->layout(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_layout__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_layout" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Grid::layout();
        } else {
          (arg1)->layout();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_layout(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Grid_layout", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Grid_layout__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 3) && (argc <= 5)) {
    PyObject *retobj = _wrap_Fl_Grid_layout__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Grid_layout'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Grid::layout(int,int,int,int)\n"
    "    Fl_Grid::layout()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_clear_layout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_clear_layout" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Grid::clear_layout();
        } else {
          (arg1)->clear_layout();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Grid_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_resize" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Grid_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Grid_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Grid_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Grid::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_rows(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_rows" "', argument " "1"" of type '" "Fl_Grid const *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  {
    try {
      result = (short)((Fl_Grid const *)arg1)->rows(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_cols(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_cols" "', argument " "1"" of type '" "Fl_Grid const *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  {
    try {
      result = (short)((Fl_Grid const *)arg1)->cols(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_short((short)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_need_layout__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 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_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_need_layout" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_need_layout" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->need_layout(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_need_layout__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_need_layout" "', argument " "1"" of type '" "Fl_Grid const *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  {
    try {
      result = (bool)((Fl_Grid const *)arg1)->need_layout(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_need_layout(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Grid_need_layout", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Grid_need_layout__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Grid_need_layout__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Grid_need_layout'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Grid::need_layout(int)\n"
    "    Fl_Grid::need_layout() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Grid *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_draw" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Grid *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_draw_grid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Grid *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_draw_grid" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw_grid"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw_grid");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Grid *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->draw_gridSwigPublic();
        } else {
          (darg)->draw_grid();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_margin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  int arg2 ;
  int arg3 = (int) -1 ;
  int arg4 = (int) -1 ;
  int arg5 = (int) -1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_margin" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_margin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Grid_margin" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Grid_margin" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Grid_margin" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = (int)(val5);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Grid::margin(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->margin(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_margin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  int *arg4 = (int *) 0 ;
  int *arg5 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_margin" "', argument " "1"" of type '" "Fl_Grid const *""'"); 
  }
  arg1 = (Fl_Grid *)(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 '" "Fl_Grid_margin" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (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 '" "Fl_Grid_margin" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Grid_margin" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Fl_Grid_margin" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  {
    try {
      result = (int)((Fl_Grid const *)arg1)->margin(arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_margin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Grid_margin", 0, 5, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 5)) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    if (argc > 2) {
      {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (!_v) goto check_1;
      if (argc > 3) {
        {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
        }
        if (!_v) goto check_1;
        if (argc > 4) {
          {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (!_v) goto check_1;
        }
      }
    }
    return _wrap_Fl_Grid_margin__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 5) {
    PyObject *retobj = _wrap_Fl_Grid_margin__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Grid_margin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Grid::margin(int,int,int,int)\n"
    "    Fl_Grid::margin(int *,int *,int *,int *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_gap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  int arg2 ;
  int arg3 = (int) -1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_gap" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_gap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Grid_gap" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Grid::gap(arg2,arg3);
        } else {
          (arg1)->gap(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_gap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 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_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_gap" "', argument " "1"" of type '" "Fl_Grid const *""'"); 
  }
  arg1 = (Fl_Grid *)(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 '" "Fl_Grid_gap" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (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 '" "Fl_Grid_gap" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  {
    try {
      ((Fl_Grid const *)arg1)->gap(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_gap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Grid_gap", 0, 3, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    if (argc > 2) {
      {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (!_v) goto check_1;
    }
    return _wrap_Fl_Grid_gap__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Grid_gap__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Grid_gap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Grid::gap(int,int)\n"
    "    Fl_Grid::gap(int *,int *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_cell__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Fl_Grid::Cell *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_cell" "', argument " "1"" of type '" "Fl_Grid const *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_cell" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Grid_cell" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (Fl_Grid::Cell *)((Fl_Grid const *)arg1)->cell(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Grid__Cell, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_cell__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Fl_Grid::Cell *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_cell" "', argument " "1"" of type '" "Fl_Grid const *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Grid_cell" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  {
    try {
      result = (Fl_Grid::Cell *)((Fl_Grid const *)arg1)->cell(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Grid__Cell, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_cell(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Grid_cell", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Grid_cell__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Grid_cell__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Grid_cell'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Grid::cell(int,int) const\n"
    "    Fl_Grid::cell(Fl_Widget *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_widget__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  int arg3 ;
  int arg4 ;
  Fl_Grid_Align arg5 = (Fl_Grid_Align) FL_GRID_FILL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  Fl_Grid::Cell *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_widget" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Grid_widget" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Grid_widget" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Grid_widget" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_unsigned_SS_short(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Grid_widget" "', argument " "5"" of type '" "Fl_Grid_Align""'");
    } 
    arg5 = (Fl_Grid_Align)(val5);
  }
  {
    try {
      result = (Fl_Grid::Cell *)(arg1)->widget(arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Grid__Cell, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_widget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  Fl_Grid_Align arg7 = (Fl_Grid_Align) FL_GRID_FILL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  unsigned short val7 ;
  int ecode7 = 0 ;
  Fl_Grid::Cell *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_widget" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Grid_widget" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Grid_widget" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Grid_widget" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Grid_widget" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Grid_widget" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_unsigned_SS_short(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Grid_widget" "', argument " "7"" of type '" "Fl_Grid_Align""'");
    } 
    arg7 = (Fl_Grid_Align)(val7);
  }
  {
    try {
      result = (Fl_Grid::Cell *)(arg1)->widget(arg2,arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Grid__Cell, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_widget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Grid_widget", 0, 7, argv))) SWIG_fail;
  --argc;
  if ((argc >= 4) && (argc <= 5)) {
    PyObject *retobj = _wrap_Fl_Grid_widget__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 6) && (argc <= 7)) {
    PyObject *retobj = _wrap_Fl_Grid_widget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Grid_widget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Grid::widget(Fl_Widget *,int,int,Fl_Grid_Align)\n"
    "    Fl_Grid::widget(Fl_Widget *,int,int,int,int,Fl_Grid_Align)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_col_width__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 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_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_col_width" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_col_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Grid_col_width" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->col_width(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_col_width__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  int *arg2 = (int *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_col_width" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  {
    size_t i;
    if (!PyList_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError, "Expecting a list");
      return NULL;
    }
    arg3 = PyList_Size(swig_obj[1]);
    arg2 = (int *) malloc((arg3)*sizeof(int));
    for (i = 0; i < arg3; i++) {
      PyObject *s = PyList_GetItem(swig_obj[1],i);
      if (!PyInt_Check(s)) {
        free(arg2);
        PyErr_SetString(PyExc_ValueError, "List items must be integers");
        return NULL;
      }
      arg2[i] = PyInt_AsLong(s);
    }
  }
  {
    try {
      (arg1)->col_width((int const *)arg2,SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if (arg2) free(arg2);
  }
  return resultobj;
fail:
  {
    if (arg2) free(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_col_width__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 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_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_col_width" "', argument " "1"" of type '" "Fl_Grid const *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_col_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Grid const *)arg1)->col_width(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_col_width(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Grid_col_width", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PyList_Check(argv[1]) ? 1 : 0;
      }
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Grid_col_width__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Grid_col_width__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Grid_col_width__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Grid_col_width'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Grid::col_width(int,int)\n"
    "    Fl_Grid::col_width(int const *,size_t)\n"
    "    Fl_Grid::col_width(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_col_weight__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 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_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_col_weight" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_col_weight" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Grid_col_weight" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->col_weight(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_col_weight__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  int *arg2 = (int *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_col_weight" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  {
    size_t i;
    if (!PyList_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError, "Expecting a list");
      return NULL;
    }
    arg3 = PyList_Size(swig_obj[1]);
    arg2 = (int *) malloc((arg3)*sizeof(int));
    for (i = 0; i < arg3; i++) {
      PyObject *s = PyList_GetItem(swig_obj[1],i);
      if (!PyInt_Check(s)) {
        free(arg2);
        PyErr_SetString(PyExc_ValueError, "List items must be integers");
        return NULL;
      }
      arg2[i] = PyInt_AsLong(s);
    }
  }
  {
    try {
      (arg1)->col_weight((int const *)arg2,SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if (arg2) free(arg2);
  }
  return resultobj;
fail:
  {
    if (arg2) free(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_col_weight__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 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_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_col_weight" "', argument " "1"" of type '" "Fl_Grid const *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_col_weight" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Grid const *)arg1)->col_weight(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_col_weight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Grid_col_weight", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PyList_Check(argv[1]) ? 1 : 0;
      }
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Grid_col_weight__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Grid_col_weight__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Grid_col_weight__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Grid_col_weight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Grid::col_weight(int,int)\n"
    "    Fl_Grid::col_weight(int const *,size_t)\n"
    "    Fl_Grid::col_weight(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_col_gap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 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_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_col_gap" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_col_gap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Grid_col_gap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->col_gap(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_col_gap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  int *arg2 = (int *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_col_gap" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  {
    size_t i;
    if (!PyList_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError, "Expecting a list");
      return NULL;
    }
    arg3 = PyList_Size(swig_obj[1]);
    arg2 = (int *) malloc((arg3)*sizeof(int));
    for (i = 0; i < arg3; i++) {
      PyObject *s = PyList_GetItem(swig_obj[1],i);
      if (!PyInt_Check(s)) {
        free(arg2);
        PyErr_SetString(PyExc_ValueError, "List items must be integers");
        return NULL;
      }
      arg2[i] = PyInt_AsLong(s);
    }
  }
  {
    try {
      (arg1)->col_gap((int const *)arg2,SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if (arg2) free(arg2);
  }
  return resultobj;
fail:
  {
    if (arg2) free(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_col_gap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 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_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_col_gap" "', argument " "1"" of type '" "Fl_Grid const *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_col_gap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Grid const *)arg1)->col_gap(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_col_gap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Grid_col_gap", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PyList_Check(argv[1]) ? 1 : 0;
      }
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Grid_col_gap__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Grid_col_gap__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Grid_col_gap__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Grid_col_gap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Grid::col_gap(int,int)\n"
    "    Fl_Grid::col_gap(int const *,size_t)\n"
    "    Fl_Grid::col_gap(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_row_height__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 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_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_row_height" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_row_height" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Grid_row_height" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->row_height(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_row_height__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  int *arg2 = (int *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_row_height" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  {
    size_t i;
    if (!PyList_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError, "Expecting a list");
      return NULL;
    }
    arg3 = PyList_Size(swig_obj[1]);
    arg2 = (int *) malloc((arg3)*sizeof(int));
    for (i = 0; i < arg3; i++) {
      PyObject *s = PyList_GetItem(swig_obj[1],i);
      if (!PyInt_Check(s)) {
        free(arg2);
        PyErr_SetString(PyExc_ValueError, "List items must be integers");
        return NULL;
      }
      arg2[i] = PyInt_AsLong(s);
    }
  }
  {
    try {
      (arg1)->row_height((int const *)arg2,SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if (arg2) free(arg2);
  }
  return resultobj;
fail:
  {
    if (arg2) free(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_row_height__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 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_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_row_height" "', argument " "1"" of type '" "Fl_Grid const *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_row_height" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Grid const *)arg1)->row_height(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_row_height(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Grid_row_height", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PyList_Check(argv[1]) ? 1 : 0;
      }
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Grid_row_height__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Grid_row_height__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Grid_row_height__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Grid_row_height'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Grid::row_height(int,int)\n"
    "    Fl_Grid::row_height(int const *,size_t)\n"
    "    Fl_Grid::row_height(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_row_weight__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 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_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_row_weight" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_row_weight" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Grid_row_weight" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->row_weight(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_row_weight__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  int *arg2 = (int *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_row_weight" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  {
    size_t i;
    if (!PyList_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError, "Expecting a list");
      return NULL;
    }
    arg3 = PyList_Size(swig_obj[1]);
    arg2 = (int *) malloc((arg3)*sizeof(int));
    for (i = 0; i < arg3; i++) {
      PyObject *s = PyList_GetItem(swig_obj[1],i);
      if (!PyInt_Check(s)) {
        free(arg2);
        PyErr_SetString(PyExc_ValueError, "List items must be integers");
        return NULL;
      }
      arg2[i] = PyInt_AsLong(s);
    }
  }
  {
    try {
      (arg1)->row_weight((int const *)arg2,SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if (arg2) free(arg2);
  }
  return resultobj;
fail:
  {
    if (arg2) free(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_row_weight__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 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_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_row_weight" "', argument " "1"" of type '" "Fl_Grid const *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_row_weight" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Grid const *)arg1)->row_weight(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_row_weight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Grid_row_weight", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PyList_Check(argv[1]) ? 1 : 0;
      }
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Grid_row_weight__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Grid_row_weight__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Grid_row_weight__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Grid_row_weight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Grid::row_weight(int,int)\n"
    "    Fl_Grid::row_weight(int const *,size_t)\n"
    "    Fl_Grid::row_weight(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_row_gap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 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_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_row_gap" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_row_gap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Grid_row_gap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->row_gap(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_row_gap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  int *arg2 = (int *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_row_gap" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  {
    size_t i;
    if (!PyList_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_ValueError, "Expecting a list");
      return NULL;
    }
    arg3 = PyList_Size(swig_obj[1]);
    arg2 = (int *) malloc((arg3)*sizeof(int));
    for (i = 0; i < arg3; i++) {
      PyObject *s = PyList_GetItem(swig_obj[1],i);
      if (!PyInt_Check(s)) {
        free(arg2);
        PyErr_SetString(PyExc_ValueError, "List items must be integers");
        return NULL;
      }
      arg2[i] = PyInt_AsLong(s);
    }
  }
  {
    try {
      (arg1)->row_gap((int const *)arg2,SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    if (arg2) free(arg2);
  }
  return resultobj;
fail:
  {
    if (arg2) free(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_row_gap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 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_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_row_gap" "', argument " "1"" of type '" "Fl_Grid const *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_row_gap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Grid const *)arg1)->row_gap(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_row_gap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Grid_row_gap", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PyList_Check(argv[1]) ? 1 : 0;
      }
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Grid_row_gap__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Grid_row_gap__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Grid_row_gap__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Grid_row_gap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Grid::row_gap(int,int)\n"
    "    Fl_Grid::row_gap(int const *,size_t)\n"
    "    Fl_Grid::row_gap(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_computed_col_width(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 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, "Fl_Grid_computed_col_width", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_computed_col_width" "', argument " "1"" of type '" "Fl_Grid const *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_computed_col_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Grid const *)arg1)->computed_col_width(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_computed_row_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 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, "Fl_Grid_computed_row_height", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_computed_row_height" "', argument " "1"" of type '" "Fl_Grid const *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_computed_row_height" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Grid const *)arg1)->computed_row_height(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_show_grid__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 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_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_show_grid" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_show_grid" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->show_grid(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_show_grid__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  int arg2 ;
  Fl_Color arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_show_grid" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_show_grid" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Grid_show_grid" "', argument " "3"" of type '" "Fl_Color""'");
  } 
  arg3 = (Fl_Color)(val3);
  {
    try {
      (arg1)->show_grid(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_show_grid(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Grid_show_grid", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Grid_show_grid__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Grid_show_grid__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Grid_show_grid'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Grid::show_grid(int)\n"
    "    Fl_Grid::show_grid(int,Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_debug(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  int arg2 = (int) 127 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Grid_debug", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_debug" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Grid_debug" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      (arg1)->debug(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Grid_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 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, "Fl_Grid_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Grid_init_type" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Grid_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Grid_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Grid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Grid *arg1 = (Fl_Grid *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Grid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Grid" "', argument " "1"" of type '" "Fl_Grid *""'"); 
  }
  arg1 = (Fl_Grid *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_GIF_Image__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  Fl_GIF_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_GIF_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_GIF_Image *)new SwigDirector_Fl_GIF_Image(arg1,(char const *)arg2); 
      } else {
        result = (Fl_GIF_Image *)new Fl_GIF_Image((char const *)arg2); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_GIF_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_GIF_Image__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  unsigned char *arg3 = (unsigned char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Fl_GIF_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_GIF_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fl_GIF_Image" "', argument " "3"" of type '" "unsigned char const *""'"); 
  }
  arg3 = (unsigned char *)(argp3);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_GIF_Image *)new SwigDirector_Fl_GIF_Image(arg1,(char const *)arg2,(unsigned char const *)arg3); 
      } else {
        result = (Fl_GIF_Image *)new Fl_GIF_Image((char const *)arg2,(unsigned char const *)arg3); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_GIF_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_GIF_Image__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  unsigned char *arg3 = (unsigned char *) 0 ;
  size_t arg4 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  Fl_GIF_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_GIF_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fl_GIF_Image" "', argument " "3"" of type '" "unsigned char const *""'"); 
  }
  arg3 = (unsigned char *)(argp3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_GIF_Image" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_GIF_Image *)new SwigDirector_Fl_GIF_Image(arg1,(char const *)arg2,(unsigned char const *)arg3,SWIG_STD_MOVE(arg4)); 
      } else {
        result = (Fl_GIF_Image *)new Fl_GIF_Image((char const *)arg2,(unsigned char const *)arg3,SWIG_STD_MOVE(arg4)); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_GIF_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_GIF_Image_is_animated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_GIF_Image_is_animated" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (bool)Fl_GIF_Image::is_animated((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_GIF_Image__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  bool arg3 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Fl_GIF_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_GIF_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_GIF_Image" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = (bool)(val3);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_GIF_Image *)new SwigDirector_Fl_GIF_Image(arg1,(char const *)arg2,arg3); 
      } else {
        SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
        SWIG_fail;
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_GIF_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_GIF_Image__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  unsigned char *arg3 = (unsigned char *) 0 ;
  size_t arg4 ;
  bool arg5 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Fl_GIF_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_GIF_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fl_GIF_Image" "', argument " "3"" of type '" "unsigned char const *""'"); 
  }
  arg3 = (unsigned char *)(argp3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_GIF_Image" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_GIF_Image" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = (bool)(val5);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_GIF_Image *)new SwigDirector_Fl_GIF_Image(arg1,(char const *)arg2,(unsigned char const *)arg3,SWIG_STD_MOVE(arg4),arg5); 
      } else {
        SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
        SWIG_fail;
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_GIF_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_GIF_Image__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  Fl_GIF_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = swig_obj[0];
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_GIF_Image *)new SwigDirector_Fl_GIF_Image(arg1); 
      } else {
        SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
        SWIG_fail;
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_GIF_Image, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_GIF_Image(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_GIF_Image", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_Fl_GIF_Image__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Fl_GIF_Image__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_new_Fl_GIF_Image__SWIG_1(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_Fl_GIF_Image__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_Fl_GIF_Image__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_new_Fl_GIF_Image__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_GIF_Image'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_GIF_Image::Fl_GIF_Image(char const *)\n"
    "    Fl_GIF_Image::Fl_GIF_Image(char const *,unsigned char const *)\n"
    "    Fl_GIF_Image::Fl_GIF_Image(char const *,unsigned char const *,size_t const)\n"
    "    Fl_GIF_Image::Fl_GIF_Image(char const *,bool)\n"
    "    Fl_GIF_Image::Fl_GIF_Image(char const *,unsigned char const *,size_t const,bool)\n"
    "    Fl_GIF_Image::Fl_GIF_Image(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_GIF_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_GIF_Image *arg1 = (Fl_GIF_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_GIF_Image, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_GIF_Image" "', argument " "1"" of type '" "Fl_GIF_Image *""'"); 
  }
  arg1 = (Fl_GIF_Image *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_GIF_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_GIF_Image *arg1 = (Fl_GIF_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_GIF_Image" "', argument " "1"" of type '" "Fl_GIF_Image *""'"); 
  }
  arg1 = (Fl_GIF_Image *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Anim_GIF_Image__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  Fl_Widget *arg3 = (Fl_Widget *) 0 ;
  unsigned short arg4 = (unsigned short) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  Fl_Anim_GIF_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_Anim_GIF_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Fl_Widget, 0 |  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fl_Anim_GIF_Image" "', argument " "3"" of type '" "Fl_Widget *""'"); 
    }
    arg3 = (Fl_Widget *)(argp3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_unsigned_SS_short(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Anim_GIF_Image" "', argument " "4"" of type '" "unsigned short""'");
    } 
    arg4 = (unsigned short)(val4);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Anim_GIF_Image *)new SwigDirector_Fl_Anim_GIF_Image(arg1,(char const *)arg2,arg3,arg4); 
      } else {
        result = (Fl_Anim_GIF_Image *)new Fl_Anim_GIF_Image((char const *)arg2,arg3,arg4); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Anim_GIF_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Anim_GIF_Image__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  unsigned char *arg3 = (unsigned char *) 0 ;
  size_t arg4 ;
  Fl_Widget *arg5 = (Fl_Widget *) 0 ;
  unsigned short arg6 = (unsigned short) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  unsigned short val6 ;
  int ecode6 = 0 ;
  Fl_Anim_GIF_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 6)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_Anim_GIF_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fl_Anim_GIF_Image" "', argument " "3"" of type '" "unsigned char const *""'"); 
  }
  arg3 = (unsigned char *)(argp3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Anim_GIF_Image" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  if (swig_obj[4]) {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_Fl_Widget, 0 |  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Fl_Anim_GIF_Image" "', argument " "5"" of type '" "Fl_Widget *""'"); 
    }
    arg5 = (Fl_Widget *)(argp5);
  }
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_unsigned_SS_short(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fl_Anim_GIF_Image" "', argument " "6"" of type '" "unsigned short""'");
    } 
    arg6 = (unsigned short)(val6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Anim_GIF_Image *)new SwigDirector_Fl_Anim_GIF_Image(arg1,(char const *)arg2,(unsigned char const *)arg3,SWIG_STD_MOVE(arg4),arg5,arg6); 
      } else {
        result = (Fl_Anim_GIF_Image *)new Fl_Anim_GIF_Image((char const *)arg2,(unsigned char const *)arg3,SWIG_STD_MOVE(arg4),arg5,arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Anim_GIF_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Anim_GIF_Image__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  Fl_Anim_GIF_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = swig_obj[0];
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Anim_GIF_Image *)new SwigDirector_Fl_Anim_GIF_Image(arg1); 
      } else {
        result = (Fl_Anim_GIF_Image *)new Fl_Anim_GIF_Image(); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Anim_GIF_Image, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Anim_GIF_Image(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_Anim_GIF_Image", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_Fl_Anim_GIF_Image__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v = 0;
    if (argc > 2) {
      {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Fl_Widget, 0);
        _v = SWIG_CheckState(res);
      }
      if (!_v) goto check_2;
      if (argc > 3) {
        {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
        }
        if (!_v) goto check_2;
      }
    }
    return _wrap_new_Fl_Anim_GIF_Image__SWIG_0(self, argc, argv);
  }
check_2:
  
  if ((argc >= 4) && (argc <= 6)) {
    PyObject *retobj = _wrap_new_Fl_Anim_GIF_Image__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_Anim_GIF_Image'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Anim_GIF_Image::Fl_Anim_GIF_Image(char const *,Fl_Widget *,unsigned short)\n"
    "    Fl_Anim_GIF_Image::Fl_Anim_GIF_Image(char const *,unsigned char const *,size_t const,Fl_Widget *,unsigned short)\n"
    "    Fl_Anim_GIF_Image::Fl_Anim_GIF_Image(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Anim_GIF_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Anim_GIF_Image" "', argument " "1"" of type '" "Fl_Anim_GIF_Image *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_load(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  char *arg2 = (char *) 0 ;
  unsigned char *arg3 = (unsigned char *) NULL ;
  size_t arg4 = (size_t) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Anim_GIF_Image_load", 2, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_load" "', argument " "1"" of type '" "Fl_Anim_GIF_Image *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Anim_GIF_Image_load" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Anim_GIF_Image_load" "', argument " "3"" of type '" "unsigned char const *""'"); 
    }
    arg3 = (unsigned char *)(argp3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Anim_GIF_Image_load" "', argument " "4"" of type '" "size_t""'");
    } 
    arg4 = (size_t)(val4);
  }
  {
    try {
      result = (bool)(arg1)->load((char const *)arg2,(unsigned char const *)arg3,SWIG_STD_MOVE(arg4)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_valid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_valid" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  {
    try {
      result = (bool)((Fl_Anim_GIF_Image const *)arg1)->valid(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_frame_uncache__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_frame_uncache" "', argument " "1"" of type '" "Fl_Anim_GIF_Image *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Anim_GIF_Image_frame_uncache" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = (bool)(val2);
  {
    try {
      (arg1)->frame_uncache(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_frame_uncache__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_frame_uncache" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  {
    try {
      result = (bool)((Fl_Anim_GIF_Image const *)arg1)->frame_uncache(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_frame_uncache(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Anim_GIF_Image_frame_uncache", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Anim_GIF_Image_frame_uncache__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Anim_GIF_Image_frame_uncache__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Anim_GIF_Image_frame_uncache'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Anim_GIF_Image::frame_uncache(bool)\n"
    "    Fl_Anim_GIF_Image::frame_uncache() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_delay__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_delay" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Anim_GIF_Image_delay" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (double)((Fl_Anim_GIF_Image const *)arg1)->delay(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_delay__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_delay" "', argument " "1"" of type '" "Fl_Anim_GIF_Image *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Anim_GIF_Image_delay" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Anim_GIF_Image_delay" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  {
    try {
      (arg1)->delay(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_delay(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Anim_GIF_Image_delay", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Anim_GIF_Image_delay__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Anim_GIF_Image_delay__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Anim_GIF_Image_delay'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Anim_GIF_Image::delay(int) const\n"
    "    Fl_Anim_GIF_Image::delay(int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_canvas__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  unsigned short arg3 = (unsigned short) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_canvas" "', argument " "1"" of type '" "Fl_Anim_GIF_Image *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Anim_GIF_Image_canvas" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_unsigned_SS_short(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Anim_GIF_Image_canvas" "', argument " "3"" of type '" "unsigned short""'");
    } 
    arg3 = (unsigned short)(val3);
  }
  {
    try {
      (arg1)->canvas(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_canvas__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_canvas" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  {
    try {
      result = (Fl_Widget *)((Fl_Anim_GIF_Image const *)arg1)->canvas(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Widget, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_canvas(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Anim_GIF_Image_canvas", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Anim_GIF_Image_canvas__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 2) && (argc <= 3)) {
    PyObject *retobj = _wrap_Fl_Anim_GIF_Image_canvas__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Anim_GIF_Image_canvas'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Anim_GIF_Image::canvas(Fl_Widget *,unsigned short)\n"
    "    Fl_Anim_GIF_Image::canvas() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_canvas_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 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_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_canvas_w" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  {
    try {
      result = (int)((Fl_Anim_GIF_Image const *)arg1)->canvas_w(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_canvas_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 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_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_canvas_h" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  {
    try {
      result = (int)((Fl_Anim_GIF_Image const *)arg1)->canvas_h(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_is_animated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_is_animated" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  {
    try {
      result = (bool)((Fl_Anim_GIF_Image const *)arg1)->is_animated(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 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_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_name" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  {
    try {
      result = (char *)((Fl_Anim_GIF_Image const *)arg1)->name(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_speed__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 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_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_speed" "', argument " "1"" of type '" "Fl_Anim_GIF_Image *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Anim_GIF_Image_speed" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      (arg1)->speed(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_speed__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 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_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_speed" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  {
    try {
      result = (double)((Fl_Anim_GIF_Image const *)arg1)->speed(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_speed(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Anim_GIF_Image_speed", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Anim_GIF_Image_speed__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Anim_GIF_Image_speed__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Anim_GIF_Image_speed'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Anim_GIF_Image::speed(double)\n"
    "    Fl_Anim_GIF_Image::speed() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_frames(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 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_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_frames" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  {
    try {
      result = (int)((Fl_Anim_GIF_Image const *)arg1)->frames(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_frame__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 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_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_frame" "', argument " "1"" of type '" "Fl_Anim_GIF_Image *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Anim_GIF_Image_frame" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->frame(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_frame__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 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_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_frame" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  {
    try {
      result = (int)((Fl_Anim_GIF_Image const *)arg1)->frame(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_frame(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Anim_GIF_Image_frame", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Anim_GIF_Image_frame__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Anim_GIF_Image_frame__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Anim_GIF_Image_frame'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Anim_GIF_Image::frame(int)\n"
    "    Fl_Anim_GIF_Image::frame() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_image__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_image" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Anim_GIF_Image const *)arg1)->image(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_image__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_image" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Anim_GIF_Image_image" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (Fl_Image *)((Fl_Anim_GIF_Image const *)arg1)->image(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_image(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Anim_GIF_Image_image", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Anim_GIF_Image_image__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Anim_GIF_Image_image__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Anim_GIF_Image_image'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Anim_GIF_Image::image() const\n"
    "    Fl_Anim_GIF_Image::image(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_start(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_start" "', argument " "1"" of type '" "Fl_Anim_GIF_Image *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  {
    try {
      result = (bool)(arg1)->start(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_stop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_stop" "', argument " "1"" of type '" "Fl_Anim_GIF_Image *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  {
    try {
      result = (bool)(arg1)->stop(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_next" "', argument " "1"" of type '" "Fl_Anim_GIF_Image *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  {
    try {
      result = (bool)(arg1)->next(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_playing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_playing" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  {
    try {
      result = (bool)((Fl_Anim_GIF_Image const *)arg1)->playing(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Swig::Director *director = 0;
  Fl_Anim_GIF_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_resize" "', argument " "1"" of type '" "Fl_Anim_GIF_Image *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Anim_GIF_Image_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Anim_GIF_Image_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (Fl_Anim_GIF_Image *) &(arg1)->resize(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Swig::Director *director = 0;
  Fl_Anim_GIF_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_resize" "', argument " "1"" of type '" "Fl_Anim_GIF_Image *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Anim_GIF_Image_resize" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      result = (Fl_Anim_GIF_Image *) &(arg1)->resize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Anim_GIF_Image_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Anim_GIF_Image_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Anim_GIF_Image_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Anim_GIF_Image_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Anim_GIF_Image::resize(int,int)\n"
    "    Fl_Anim_GIF_Image::resize(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_frame_x(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 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, "Fl_Anim_GIF_Image_frame_x", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_frame_x" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Anim_GIF_Image_frame_x" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Anim_GIF_Image const *)arg1)->frame_x(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_frame_y(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 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, "Fl_Anim_GIF_Image_frame_y", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_frame_y" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Anim_GIF_Image_frame_y" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Anim_GIF_Image const *)arg1)->frame_y(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_frame_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 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, "Fl_Anim_GIF_Image_frame_w", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_frame_w" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Anim_GIF_Image_frame_w" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Anim_GIF_Image const *)arg1)->frame_w(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_frame_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 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, "Fl_Anim_GIF_Image_frame_h", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_frame_h" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Anim_GIF_Image_frame_h" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Anim_GIF_Image const *)arg1)->frame_h(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_color_average(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  Fl_Color arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Anim_GIF_Image_color_average", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_color_average" "', argument " "1"" of type '" "Fl_Anim_GIF_Image *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Anim_GIF_Image_color_average" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Anim_GIF_Image_color_average" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = (float)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Anim_GIF_Image::color_average(arg2,arg3);
        } else {
          (arg1)->color_average(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_copy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_copy" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Anim_GIF_Image_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Anim_GIF_Image_copy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Image *)((Fl_Anim_GIF_Image const *)arg1)->Fl_Anim_GIF_Image::copy(arg2,arg3);
        } else {
          result = (Fl_Image *)((Fl_Anim_GIF_Image const *)arg1)->copy(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, SWIG_POINTER_OWN |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_copy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_copy" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Anim_GIF_Image const *)arg1)->copy(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_copy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Anim_GIF_Image_copy", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Anim_GIF_Image_copy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Anim_GIF_Image_copy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Anim_GIF_Image_copy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Anim_GIF_Image::copy(int,int) const\n"
    "    Fl_Anim_GIF_Image::copy() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_desaturate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_desaturate" "', argument " "1"" of type '" "Fl_Anim_GIF_Image *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Anim_GIF_Image::desaturate();
        } else {
          (arg1)->desaturate();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 = (int) 0 ;
  int arg7 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Anim_GIF_Image_draw", 5, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_draw" "', argument " "1"" of type '" "Fl_Anim_GIF_Image *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Anim_GIF_Image_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Anim_GIF_Image_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Anim_GIF_Image_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Anim_GIF_Image_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Anim_GIF_Image_draw" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Anim_GIF_Image_draw" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Anim_GIF_Image::draw(arg2,arg3,arg4,arg5,arg6,arg7);
        } else {
          (arg1)->draw(arg2,arg3,arg4,arg5,arg6,arg7);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_uncache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_uncache" "', argument " "1"" of type '" "Fl_Anim_GIF_Image *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Anim_GIF_Image::uncache();
        } else {
          (arg1)->uncache();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_debug(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 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_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_debug" "', argument " "1"" of type '" "Fl_Anim_GIF_Image const *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  {
    try {
      result = (int)((Fl_Anim_GIF_Image const *)arg1)->debug(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Anim_GIF_Image_frame_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  unsigned char *arg2 = (unsigned char *) NULL ;
  size_t arg3 = (size_t) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Anim_GIF_Image_frame_count", 1, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Anim_GIF_Image_frame_count" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Anim_GIF_Image_frame_count" "', argument " "2"" of type '" "unsigned char const *""'"); 
    }
    arg2 = (unsigned char *)(argp2);
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Anim_GIF_Image_frame_count" "', argument " "3"" of type '" "size_t""'");
    } 
    arg3 = (size_t)(val3);
  }
  {
    try {
      result = (int)Fl_Anim_GIF_Image::frame_count((char const *)arg1,(unsigned char const *)arg2,SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Anim_GIF_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Anim_GIF_Image *arg1 = (Fl_Anim_GIF_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Anim_GIF_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Anim_GIF_Image" "', argument " "1"" of type '" "Fl_Anim_GIF_Image *""'"); 
  }
  arg1 = (Fl_Anim_GIF_Image *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_ICO_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 = (int) -1 ;
  unsigned char *arg4 = (unsigned char *) NULL ;
  size_t arg5 = (size_t) (size_t)0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Fl_ICO_Image *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_ICO_Image", 2, 5, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_ICO_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_ICO_Image" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  if (swig_obj[3]) {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_unsigned_char, 0 |  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Fl_ICO_Image" "', argument " "4"" of type '" "unsigned char const *""'"); 
    }
    arg4 = (unsigned char *)(argp4);
  }
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_ICO_Image" "', argument " "5"" of type '" "size_t""'");
    } 
    arg5 = (size_t)(val5);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_ICO_Image *)new SwigDirector_Fl_ICO_Image(arg1,(char const *)arg2,arg3,(unsigned char const *)arg4,SWIG_STD_MOVE(arg5)); 
      } else {
        result = (Fl_ICO_Image *)new Fl_ICO_Image((char const *)arg2,arg3,(unsigned char const *)arg4,SWIG_STD_MOVE(arg5)); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_ICO_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_ICO_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_ICO_Image *arg1 = (Fl_ICO_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_ICO_Image, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_ICO_Image" "', argument " "1"" of type '" "Fl_ICO_Image *""'"); 
  }
  arg1 = (Fl_ICO_Image *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_ICO_Image_idcount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_ICO_Image *arg1 = (Fl_ICO_Image *) 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_Fl_ICO_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_ICO_Image_idcount" "', argument " "1"" of type '" "Fl_ICO_Image const *""'"); 
  }
  arg1 = (Fl_ICO_Image *)(argp1);
  {
    try {
      result = (int)((Fl_ICO_Image const *)arg1)->idcount(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_ICO_Image_icondirentry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_ICO_Image *arg1 = (Fl_ICO_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_ICO_Image::IconDirEntry *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_ICO_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_ICO_Image_icondirentry" "', argument " "1"" of type '" "Fl_ICO_Image const *""'"); 
  }
  arg1 = (Fl_ICO_Image *)(argp1);
  {
    try {
      result = (Fl_ICO_Image::IconDirEntry *)((Fl_ICO_Image const *)arg1)->icondirentry(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_ICO_Image__IconDirEntry, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_ICO_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_ICO_Image *arg1 = (Fl_ICO_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_ICO_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_ICO_Image" "', argument " "1"" of type '" "Fl_ICO_Image *""'"); 
  }
  arg1 = (Fl_ICO_Image *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Image_Surface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 = (int) 0 ;
  Fl_Offscreen arg4 = (Fl_Offscreen) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  Fl_Image_Surface *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Image_Surface", 2, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Fl_Image_Surface" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Image_Surface" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Image_Surface" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  if (swig_obj[3]) {
    {
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Fl_Offscreen,  0  | 0);
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Fl_Image_Surface" "', argument " "4"" of type '" "Fl_Offscreen""'"); 
      }  
      if (!argp4) {
        SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Fl_Image_Surface" "', argument " "4"" of type '" "Fl_Offscreen""'");
      } else {
        Fl_Offscreen * temp = (Fl_Offscreen *)(argp4);
        arg4 = *temp;
        if (SWIG_IsNewObj(res4)) delete temp;
      }
    }
  }
  {
    try {
      result = (Fl_Image_Surface *)new Fl_Image_Surface(arg1,arg2,arg3,SWIG_STD_MOVE(arg4)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image_Surface, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Image_Surface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image_Surface *arg1 = (Fl_Image_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image_Surface, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Image_Surface" "', argument " "1"" of type '" "Fl_Image_Surface *""'"); 
  }
  arg1 = (Fl_Image_Surface *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_Surface_set_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image_Surface *arg1 = (Fl_Image_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_Surface_set_current" "', argument " "1"" of type '" "Fl_Image_Surface *""'"); 
  }
  arg1 = (Fl_Image_Surface *)(argp1);
  {
    try {
      (arg1)->set_current(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_Surface_is_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image_Surface *arg1 = (Fl_Image_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_Surface_is_current" "', argument " "1"" of type '" "Fl_Image_Surface *""'"); 
  }
  arg1 = (Fl_Image_Surface *)(argp1);
  {
    try {
      result = (bool)(arg1)->is_current(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_Surface_image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image_Surface *arg1 = (Fl_Image_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_RGB_Image *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_Surface_image" "', argument " "1"" of type '" "Fl_Image_Surface *""'"); 
  }
  arg1 = (Fl_Image_Surface *)(argp1);
  {
    try {
      result = (Fl_RGB_Image *)(arg1)->image(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_Surface_highres_image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image_Surface *arg1 = (Fl_Image_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Shared_Image *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_Surface_highres_image" "', argument " "1"" of type '" "Fl_Image_Surface *""'"); 
  }
  arg1 = (Fl_Image_Surface *)(argp1);
  {
    try {
      result = (Fl_Shared_Image *)(arg1)->highres_image(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Shared_Image, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_Surface_origin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Image_Surface *arg1 = (Fl_Image_Surface *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 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_Fl_Image_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_Surface_origin" "', argument " "1"" of type '" "Fl_Image_Surface *""'"); 
  }
  arg1 = (Fl_Image_Surface *)(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 '" "Fl_Image_Surface_origin" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (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 '" "Fl_Image_Surface_origin" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  {
    try {
      (arg1)->origin(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_Surface_origin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Image_Surface *arg1 = (Fl_Image_Surface *) 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_Fl_Image_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_Surface_origin" "', argument " "1"" of type '" "Fl_Image_Surface *""'"); 
  }
  arg1 = (Fl_Image_Surface *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Image_Surface_origin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Image_Surface_origin" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->origin(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_Surface_origin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Image_Surface_origin", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Image_Surface_origin__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Image_Surface_origin__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Image_Surface_origin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Image_Surface::origin(int *,int *)\n"
    "    Fl_Image_Surface::origin(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Image_Surface_printable_rect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image_Surface *arg1 = (Fl_Image_Surface *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Image_Surface_printable_rect", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_Surface_printable_rect" "', argument " "1"" of type '" "Fl_Image_Surface *""'"); 
  }
  arg1 = (Fl_Image_Surface *)(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 '" "Fl_Image_Surface_printable_rect" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (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 '" "Fl_Image_Surface_printable_rect" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  {
    try {
      result = (int)(arg1)->printable_rect(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_Surface_offscreen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image_Surface *arg1 = (Fl_Image_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Offscreen result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_Surface_offscreen" "', argument " "1"" of type '" "Fl_Image_Surface *""'"); 
  }
  arg1 = (Fl_Image_Surface *)(argp1);
  {
    try {
      result = (arg1)->offscreen(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new Fl_Offscreen(result)), SWIGTYPE_p_Fl_Offscreen, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_Surface_rescale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image_Surface *arg1 = (Fl_Image_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_Surface_rescale" "', argument " "1"" of type '" "Fl_Image_Surface *""'"); 
  }
  arg1 = (Fl_Image_Surface *)(argp1);
  {
    try {
      (arg1)->rescale(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_Surface_mask(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image_Surface *arg1 = (Fl_Image_Surface *) 0 ;
  Fl_RGB_Image *arg2 = (Fl_RGB_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Image_Surface_mask", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Image_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Image_Surface_mask" "', argument " "1"" of type '" "Fl_Image_Surface *""'"); 
  }
  arg1 = (Fl_Image_Surface *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Image_Surface_mask" "', argument " "2"" of type '" "Fl_RGB_Image const *""'"); 
  }
  arg2 = (Fl_RGB_Image *)(argp2);
  {
    try {
      (arg1)->mask((Fl_RGB_Image const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_fl_strdup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  char *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 '" "fl_strdup" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (char *)fl_strdup((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_strlcpy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_strlcpy", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_strlcpy" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_strlcpy" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_strlcpy" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = (size_t)(val3);
  {
    try {
      result = fl_strlcpy(arg1,(char const *)arg2,SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t((size_t)(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Gl_Window *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_draw" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Gl_Window *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_flush(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_flush" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Gl_Window::flush();
        } else {
          (arg1)->flush();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_hide(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_hide" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Gl_Window::hide();
        } else {
          (arg1)->hide();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Gl_Window_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_resize" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Gl_Window_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Gl_Window_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Gl_Window_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Gl_Window_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Gl_Window::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Gl_Window_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_handle" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Gl_Window_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Gl_Window::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_valid__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_valid" "', argument " "1"" of type '" "Fl_Gl_Window const *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    try {
      result = (char)((Fl_Gl_Window const *)arg1)->valid(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_valid__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_valid" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Gl_Window_valid" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = (char)(val2);
  {
    try {
      (arg1)->valid(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_valid(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Gl_Window_valid", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Gl_Window_valid__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Gl_Window_valid__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Gl_Window_valid'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Gl_Window::valid() const\n"
    "    Fl_Gl_Window::valid(char)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_invalidate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_invalidate" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    try {
      (arg1)->invalidate(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_context_valid__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_context_valid" "', argument " "1"" of type '" "Fl_Gl_Window const *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    try {
      result = (char)((Fl_Gl_Window const *)arg1)->context_valid(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_context_valid__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_context_valid" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Gl_Window_context_valid" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = (char)(val2);
  {
    try {
      (arg1)->context_valid(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_context_valid(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Gl_Window_context_valid", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Gl_Window_context_valid__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Gl_Window_context_valid__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Gl_Window_context_valid'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Gl_Window::context_valid() const\n"
    "    Fl_Gl_Window::context_valid(char)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_can_do__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Gl_Window_can_do" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      result = (int)Fl_Gl_Window::can_do(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_can_do__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int *arg1 = (int *) 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_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_can_do" "', argument " "1"" of type '" "int const *""'"); 
  }
  arg1 = (int *)(argp1);
  {
    try {
      result = (int)Fl_Gl_Window::can_do((int const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_can_do__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 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_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_can_do" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    try {
      result = (int)(arg1)->can_do(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_can_do(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Gl_Window_can_do", 0, 1, argv))) SWIG_fail;
  --argc;
  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) goto check_1;
    return _wrap_Fl_Gl_Window_can_do__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Fl_Gl_Window, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_Fl_Gl_Window_can_do__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Gl_Window_can_do__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Gl_Window_can_do'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Gl_Window::can_do(int)\n"
    "    Fl_Gl_Window::can_do(int const *)\n"
    "    Fl_Gl_Window::can_do()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_mode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Mode result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_mode" "', argument " "1"" of type '" "Fl_Gl_Window const *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    try {
      result = (Fl_Mode)((Fl_Gl_Window const *)arg1)->mode(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_mode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 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_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_mode" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Gl_Window_mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)(arg1)->mode(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_mode__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_mode" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(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 '" "Fl_Gl_Window_mode" "', argument " "2"" of type '" "int const *""'"); 
  }
  arg2 = (int *)(argp2);
  {
    try {
      result = (int)(arg1)->mode((int const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_mode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Gl_Window_mode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Gl_Window_mode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_Fl_Gl_Window_mode__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Gl_Window_mode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Gl_Window_mode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Gl_Window::mode() const\n"
    "    Fl_Gl_Window::mode(int)\n"
    "    Fl_Gl_Window::mode(int const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_context__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GLContext result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_context" "', argument " "1"" of type '" "Fl_Gl_Window const *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    try {
      result = ((Fl_Gl_Window const *)arg1)->context(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new GLContext(result)), SWIGTYPE_p_GLContext, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_context__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  GLContext arg2 ;
  int arg3 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_context" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_GLContext,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Gl_Window_context" "', argument " "2"" of type '" "GLContext""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Gl_Window_context" "', argument " "2"" of type '" "GLContext""'");
    } else {
      GLContext * temp = (GLContext *)(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Gl_Window_context" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      (arg1)->context(SWIG_STD_MOVE(arg2),arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_context(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Gl_Window_context", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Gl_Window_context__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 2) && (argc <= 3)) {
    PyObject *retobj = _wrap_Fl_Gl_Window_context__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Gl_Window_context'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Gl_Window::context() const\n"
    "    Fl_Gl_Window::context(GLContext,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_make_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_make_current" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    try {
      (arg1)->make_current(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_swap_buffers(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_swap_buffers" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    try {
      (arg1)->swap_buffers(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_swap_interval__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 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_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_swap_interval" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Gl_Window_swap_interval" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->swap_interval(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_swap_interval__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 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_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_swap_interval" "', argument " "1"" of type '" "Fl_Gl_Window const *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    try {
      result = (int)((Fl_Gl_Window const *)arg1)->swap_interval(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_swap_interval(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Gl_Window_swap_interval", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Gl_Window_swap_interval__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Gl_Window_swap_interval__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Gl_Window_swap_interval'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Gl_Window::swap_interval(int)\n"
    "    Fl_Gl_Window::swap_interval() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_ortho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_ortho" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    try {
      (arg1)->ortho(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_can_do_overlay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 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_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_can_do_overlay" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    try {
      result = (int)(arg1)->can_do_overlay(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_redraw_overlay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_redraw_overlay" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    try {
      (arg1)->redraw_overlay(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_hide_overlay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_hide_overlay" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    try {
      (arg1)->hide_overlay(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_make_overlay_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_make_overlay_current" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    try {
      (arg1)->make_overlay_current(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_as_gl_window__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Gl_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_as_gl_window" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Gl_Window *)(arg1)->Fl_Gl_Window::as_gl_window();
        } else {
          result = (Fl_Gl_Window *)(arg1)->as_gl_window();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_as_gl_window__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Gl_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_as_gl_window" "', argument " "1"" of type '" "Fl_Gl_Window const *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Gl_Window *)((Fl_Gl_Window const *)arg1)->Fl_Gl_Window::as_gl_window();
        } else {
          result = (Fl_Gl_Window *)((Fl_Gl_Window const *)arg1)->as_gl_window();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_as_gl_window(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Gl_Window_as_gl_window", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Gl_Window_as_gl_window__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Gl_Window_as_gl_window__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Gl_Window_as_gl_window'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Gl_Window::as_gl_window()\n"
    "    Fl_Gl_Window::as_gl_window() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_pixels_per_unit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 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_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_pixels_per_unit" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    try {
      result = (float)(arg1)->pixels_per_unit(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_float((float)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_pixel_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 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_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_pixel_w" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    try {
      result = (int)(arg1)->pixel_w(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_pixel_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 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_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_pixel_h" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    try {
      result = (int)(arg1)->pixel_h(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Gl_Window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Gl_Window" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Gl_Window__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  char *arg4 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  Fl_Gl_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Gl_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Gl_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  if (swig_obj[3]) {
    res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Fl_Gl_Window" "', argument " "4"" of type '" "char const *""'");
    }
    arg4 = (char *)(buf4);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Gl_Window *)new SwigDirector_Fl_Gl_Window(arg1,arg2,arg3,(char const *)arg4); 
      } else {
        result = (Fl_Gl_Window *)new Fl_Gl_Window(arg2,arg3,(char const *)arg4); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Gl_Window, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Gl_Window__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  Fl_Gl_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Gl_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Gl_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Gl_Window" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Gl_Window" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Gl_Window" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Gl_Window *)new SwigDirector_Fl_Gl_Window(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Gl_Window *)new Fl_Gl_Window(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Gl_Window, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Gl_Window(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_Gl_Window", 0, 6, argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    PyObject *retobj = _wrap_new_Fl_Gl_Window__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 5) && (argc <= 6)) {
    PyObject *retobj = _wrap_new_Fl_Gl_Window__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_Gl_Window'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Gl_Window::Fl_Gl_Window(int,int,char const *)\n"
    "    Fl_Gl_Window::Fl_Gl_Window(PyObject *,int,int,int,int,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 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, "Fl_Gl_Window_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_init_type" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Gl_Window_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Gl_Window_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_show(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Gl_Window_show", 1, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_show" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  if (swig_obj[1]) {
    arg2 = swig_obj[1];
  }
  if (swig_obj[2]) {
    arg3 = swig_obj[2];
  }
  {
    try {
      Fl_Gl_Window_show(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_drawPixels(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Gl_Window_drawPixels", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Gl_Window_drawPixels" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  arg2 = swig_obj[1];
  {
    try {
      Fl_Gl_Window_drawPixels(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Gl_Window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Gl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Gl_Window" "', argument " "1"" of type '" "Fl_Gl_Window *""'"); 
  }
  arg1 = (Fl_Gl_Window *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_gl_start(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "gl_start", 0, 0, 0)) SWIG_fail;
  {
    try {
      gl_start(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_finish(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "gl_finish", 0, 0, 0)) SWIG_fail;
  {
    try {
      gl_finish(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gl_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  {
    try {
      gl_color(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 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 '" "gl_color" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      gl_color(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "gl_color", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_gl_color__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_gl_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'gl_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gl_color(Fl_Color)\n"
    "    gl_color(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_gl_rect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "gl_rect", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gl_rect" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_rect" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gl_rect" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gl_rect" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      gl_rect(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_rectf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "gl_rectf", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gl_rectf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_rectf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gl_rectf" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gl_rectf" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      gl_rectf(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_font(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "gl_font", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gl_font" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_font" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      gl_font(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "gl_height", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)gl_height(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_descent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "gl_descent", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)gl_descent(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_width__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  double 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 '" "gl_width" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (double)gl_width((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_width__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double result;
  
  (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 '" "gl_width" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (double)gl_width((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_width__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  uchar arg1 ;
  unsigned char val1 ;
  int ecode1 = 0 ;
  double result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gl_width" "', argument " "1"" of type '" "uchar""'");
  } 
  arg1 = (uchar)(val1);
  {
    try {
      result = (double)gl_width(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_width(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "gl_width", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_char(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_gl_width__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_gl_width__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_gl_width__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'gl_width'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gl_width(char const *)\n"
    "    gl_width(char const *,int)\n"
    "    gl_width(uchar)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_gl_draw__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  
  (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 '" "gl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      gl_draw((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_draw__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 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 '" "gl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      gl_draw((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_draw__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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 '" "gl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      gl_draw((char const *)arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_draw__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  float arg2 ;
  float arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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 '" "gl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_draw" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = (float)(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gl_draw" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = (float)(val3);
  {
    try {
      gl_draw((char const *)arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_draw__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 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_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gl_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      gl_draw((char const *)arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_draw__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  float arg3 ;
  float arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gl_draw" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = (float)(val3);
  ecode4 = SWIG_AsVal_float(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gl_draw" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = (float)(val4);
  {
    try {
      gl_draw((char const *)arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_draw__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  Fl_Align arg6 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gl_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gl_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "gl_draw" "', argument " "6"" of type '" "Fl_Align""'");
  } 
  arg6 = (Fl_Align)(val6);
  {
    try {
      gl_draw((char const *)arg1,arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_draw(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "gl_draw", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_gl_draw__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_gl_draw__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    return _wrap_gl_draw__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_gl_draw__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    {
      {
        int res = SWIG_AsVal_int(argv[3], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_gl_draw__SWIG_4(self, argc, argv);
  }
check_5:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_gl_draw__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_gl_draw__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'gl_draw'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gl_draw(char const *)\n"
    "    gl_draw(char const *,int)\n"
    "    gl_draw(char const *,int,int)\n"
    "    gl_draw(char const *,float,float)\n"
    "    gl_draw(char const *,int,int,int)\n"
    "    gl_draw(char const *,int,float,float)\n"
    "    gl_draw(char const *,int,int,int,int,Fl_Align)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_gl_measure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int 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_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gl_measure" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      gl_measure((char const *)arg1,*arg2,*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_texture_pile_height__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 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 '" "gl_texture_pile_height" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      gl_texture_pile_height(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_texture_pile_height__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)gl_texture_pile_height(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_texture_pile_height(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "gl_texture_pile_height", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_gl_texture_pile_height__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_gl_texture_pile_height__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'gl_texture_pile_height'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    gl_texture_pile_height(int)\n"
    "    gl_texture_pile_height()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_gl_texture_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "gl_texture_reset", 0, 0, 0)) SWIG_fail;
  {
    try {
      gl_texture_reset(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_draw_image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uchar *arg1 = (uchar *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 = (int) 3 ;
  int arg7 = (int) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "gl_draw_image", 5, 7, swig_obj)) SWIG_fail;
  {
    /* Check if the input support the buffer protocol */
    Py_buffer view;
    const void * buffer;
    int failure = PyObject_GetBuffer(swig_obj[0], &view, PyBUF_CONTIG_RO);
    if (!failure) {
      // work with array object
      buffer = view.buf;
      PyBuffer_Release(&view);
      arg1 = (uchar *) buffer;
    } else {
      // work with list object
      // clear the error from PyObject_GetBuffer
      PyErr_Clear();
      buffer=0;
      /* Check if is a list */
      if (PyList_Check(swig_obj[0])) {
        Py_ssize_t size = PyList_Size(swig_obj[0]);
        int i = 0;
        arg1 = (uchar *) malloc((size+1)*sizeof(char));
        for (i = 0; i < size; i++) {
          PyObject *o = 	PyList_GetItem(swig_obj[0],i);
          if (PyInt_Check(o))
          arg1[i] = (char)PyInt_AsLong(o);
          else {
            PyErr_SetString(PyExc_TypeError,"list must contain ints");
            free(arg1);
            return NULL;
          }
        }
        arg1[i] = 0;
      } else {
        PyErr_SetString(PyExc_TypeError,"not a list or does not support single-segment readable buffer interface");
        return NULL;
      }
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_draw_image" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gl_draw_image" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gl_draw_image" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gl_draw_image" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "gl_draw_image" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gl_draw_image" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  {
    try {
      gl_draw_image((unsigned char const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Help_Dialog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Help_Dialog", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Help_Dialog *)new Fl_Help_Dialog(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Help_Dialog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Help_Dialog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_Dialog, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Help_Dialog" "', argument " "1"" of type '" "Fl_Help_Dialog *""'"); 
  }
  arg1 = (Fl_Help_Dialog *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 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_Fl_Help_Dialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Dialog_h" "', argument " "1"" of type '" "Fl_Help_Dialog *""'"); 
  }
  arg1 = (Fl_Help_Dialog *)(argp1);
  {
    try {
      result = (int)(arg1)->h(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_hide(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_Dialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Dialog_hide" "', argument " "1"" of type '" "Fl_Help_Dialog *""'"); 
  }
  arg1 = (Fl_Help_Dialog *)(argp1);
  {
    try {
      (arg1)->hide(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_load(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  char *arg2 = (char *) 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, "Fl_Help_Dialog_load", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_Dialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Dialog_load" "', argument " "1"" of type '" "Fl_Help_Dialog *""'"); 
  }
  arg1 = (Fl_Help_Dialog *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Help_Dialog_load" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)(arg1)->load((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_position(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 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, "Fl_Help_Dialog_position", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_Dialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Dialog_position" "', argument " "1"" of type '" "Fl_Help_Dialog *""'"); 
  }
  arg1 = (Fl_Help_Dialog *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_Dialog_position" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Help_Dialog_position" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->position(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Help_Dialog_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_Dialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Dialog_resize" "', argument " "1"" of type '" "Fl_Help_Dialog *""'"); 
  }
  arg1 = (Fl_Help_Dialog *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_Dialog_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Help_Dialog_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Help_Dialog_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Help_Dialog_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      (arg1)->resize(arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_show__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 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_Fl_Help_Dialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Dialog_show" "', argument " "1"" of type '" "Fl_Help_Dialog *""'"); 
  }
  arg1 = (Fl_Help_Dialog *)(argp1);
  {
    try {
      (arg1)->show(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_show__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  int arg2 ;
  char **arg3 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_Dialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Dialog_show" "', argument " "1"" of type '" "Fl_Help_Dialog *""'"); 
  }
  arg1 = (Fl_Help_Dialog *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_Dialog_show" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    /* Check if it is a list */
    if (PyList_Check(swig_obj[2])) {
      Py_ssize_t size = PyList_Size(swig_obj[2]);
      int i = 0;
      arg3 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[2],i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg3[i] = PyString_AsString(PyList_GetItem(swig_obj[2],i));
          //arg3[i] = SWIG_Python_str_AsChar(PyList_GetItem(swig_obj[2],i));
          arg3[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(swig_obj[2],i)));
        }
        else {
          PyErr_SetString(PyExc_TypeError,"list must contain strings");
          free(arg3);
          return NULL;
        }
        
      }
      arg3[i] = NULL;
      
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  {
    try {
      (arg1)->show(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg3);
  }
  return resultobj;
fail:
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_show(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Help_Dialog_show", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Help_Dialog_show__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Help_Dialog_show__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Help_Dialog_show'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Help_Dialog::show()\n"
    "    Fl_Help_Dialog::show(int,char **)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_textsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  Fl_Fontsize 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_Fl_Help_Dialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Dialog_textsize" "', argument " "1"" of type '" "Fl_Help_Dialog *""'"); 
  }
  arg1 = (Fl_Help_Dialog *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_Dialog_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->textsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_textsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_Dialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Dialog_textsize" "', argument " "1"" of type '" "Fl_Help_Dialog *""'"); 
  }
  arg1 = (Fl_Help_Dialog *)(argp1);
  {
    try {
      result = (Fl_Fontsize)(arg1)->textsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_textsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Help_Dialog_textsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Help_Dialog_textsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Help_Dialog_textsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Help_Dialog_textsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Help_Dialog::textsize(Fl_Fontsize)\n"
    "    Fl_Help_Dialog::textsize()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_topline__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_Dialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Dialog_topline" "', argument " "1"" of type '" "Fl_Help_Dialog *""'"); 
  }
  arg1 = (Fl_Help_Dialog *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Help_Dialog_topline" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->topline((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_topline__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 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_Fl_Help_Dialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Dialog_topline" "', argument " "1"" of type '" "Fl_Help_Dialog *""'"); 
  }
  arg1 = (Fl_Help_Dialog *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_Dialog_topline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->topline(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_topline(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Help_Dialog_topline", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Help_Dialog_topline__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Help_Dialog_topline__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Help_Dialog_topline'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Help_Dialog::topline(char const *)\n"
    "    Fl_Help_Dialog::topline(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_Dialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Dialog_value" "', argument " "1"" of type '" "Fl_Help_Dialog *""'"); 
  }
  arg1 = (Fl_Help_Dialog *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Help_Dialog_value" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->value((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_Dialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Dialog_value" "', argument " "1"" of type '" "Fl_Help_Dialog const *""'"); 
  }
  arg1 = (Fl_Help_Dialog *)(argp1);
  {
    try {
      result = (char *)((Fl_Help_Dialog const *)arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Help_Dialog_value", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Help_Dialog_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Help_Dialog_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Help_Dialog_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Help_Dialog::value(char const *)\n"
    "    Fl_Help_Dialog::value() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_visible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 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_Fl_Help_Dialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Dialog_visible" "', argument " "1"" of type '" "Fl_Help_Dialog *""'"); 
  }
  arg1 = (Fl_Help_Dialog *)(argp1);
  {
    try {
      result = (int)(arg1)->visible(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 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_Fl_Help_Dialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Dialog_w" "', argument " "1"" of type '" "Fl_Help_Dialog *""'"); 
  }
  arg1 = (Fl_Help_Dialog *)(argp1);
  {
    try {
      result = (int)(arg1)->w(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_x(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 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_Fl_Help_Dialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Dialog_x" "', argument " "1"" of type '" "Fl_Help_Dialog *""'"); 
  }
  arg1 = (Fl_Help_Dialog *)(argp1);
  {
    try {
      result = (int)(arg1)->x(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_y(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 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_Fl_Help_Dialog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Dialog_y" "', argument " "1"" of type '" "Fl_Help_Dialog *""'"); 
  }
  arg1 = (Fl_Help_Dialog *)(argp1);
  {
    try {
      result = (int)(arg1)->y(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Help_View_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Help_View *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_draw" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Help_View *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Help_View(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Help_View *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Help_View", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Help_View" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Help_View" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Help_View" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Help_View" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Help_View" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Help_View *)new SwigDirector_Fl_Help_View(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Help_View *)new Fl_Help_View(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Help_View, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Help_View(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Help_View" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Help_View_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_handle" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_View_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Help_View::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Help_View_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_resize" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_View_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Help_View_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Help_View_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Help_View_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Help_View::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 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_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_size" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_View_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Help_View_size" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->size(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_value" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Help_View_value" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->value((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_value" "', argument " "1"" of type '" "Fl_Help_View const *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  {
    try {
      result = (char *)((Fl_Help_View const *)arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Help_View_value", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Help_View_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Help_View_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Help_View_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Help_View::value(char const *)\n"
    "    Fl_Help_View::value() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_load(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  char *arg2 = (char *) 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, "Fl_Help_View_load", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_load" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Help_View_load" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)(arg1)->load((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Help_View_find", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_find" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Help_View_find" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Help_View_find" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->find((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_link__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  Fl_Help_Func *arg2 = (Fl_Help_Func *) 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_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_link" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_Fl_Widget_p_q_const__char__p_char);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Help_View_link" "', argument " "2"" of type '" "Fl_Help_Func *""'"); 
    }
  }
  {
    try {
      (arg1)->link(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_filename(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 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_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_filename" "', argument " "1"" of type '" "Fl_Help_View const *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  {
    try {
      result = (char *)((Fl_Help_View const *)arg1)->filename(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_directory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 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_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_directory" "', argument " "1"" of type '" "Fl_Help_View const *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  {
    try {
      result = (char *)((Fl_Help_View const *)arg1)->directory(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_title(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 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_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_title" "', argument " "1"" of type '" "Fl_Help_View const *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  {
    try {
      result = (char *)((Fl_Help_View const *)arg1)->title(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 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_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_size" "', argument " "1"" of type '" "Fl_Help_View const *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  {
    try {
      result = (int)((Fl_Help_View const *)arg1)->size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Help_View_size", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Help_View_size__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Help_View_size__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Help_View_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Help_View::size(int,int)\n"
    "    Fl_Help_View::size() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_textcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_textcolor" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_View_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->textcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_textcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_textcolor" "', argument " "1"" of type '" "Fl_Help_View const *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Help_View const *)arg1)->textcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_textcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Help_View_textcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Help_View_textcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Help_View_textcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Help_View_textcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Help_View::textcolor(Fl_Color)\n"
    "    Fl_Help_View::textcolor() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_textfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  Fl_Font 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_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_textfont" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_View_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->textfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_textfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_textfont" "', argument " "1"" of type '" "Fl_Help_View const *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Help_View const *)arg1)->textfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_textfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Help_View_textfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Help_View_textfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Help_View_textfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Help_View_textfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Help_View::textfont(Fl_Font)\n"
    "    Fl_Help_View::textfont() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_textsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  Fl_Fontsize 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_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_textsize" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_View_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->textsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_textsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_textsize" "', argument " "1"" of type '" "Fl_Help_View const *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Help_View const *)arg1)->textsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_textsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Help_View_textsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Help_View_textsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Help_View_textsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Help_View_textsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Help_View::textsize(Fl_Fontsize)\n"
    "    Fl_Help_View::textsize() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_topline__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_topline" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Help_View_topline" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->topline((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_topline__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 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_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_topline" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_View_topline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->topline(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_topline__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 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_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_topline" "', argument " "1"" of type '" "Fl_Help_View const *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  {
    try {
      result = (int)((Fl_Help_View const *)arg1)->topline(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_topline(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Help_View_topline", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Help_View_topline__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_Fl_Help_View_topline__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Help_View_topline__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Help_View_topline'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Help_View::topline(char const *)\n"
    "    Fl_Help_View::topline(int)\n"
    "    Fl_Help_View::topline() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_leftline__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 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_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_leftline" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_View_leftline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->leftline(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_leftline__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 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_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_leftline" "', argument " "1"" of type '" "Fl_Help_View const *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  {
    try {
      result = (int)((Fl_Help_View const *)arg1)->leftline(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_leftline(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Help_View_leftline", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Help_View_leftline__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Help_View_leftline__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Help_View_leftline'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Help_View::leftline(int)\n"
    "    Fl_Help_View::leftline() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_clear_selection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_clear_selection" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  {
    try {
      (arg1)->clear_selection(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_select_all(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_select_all" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  {
    try {
      (arg1)->select_all(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_text_selected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 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_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_text_selected" "', argument " "1"" of type '" "Fl_Help_View const *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  {
    try {
      result = (int)((Fl_Help_View const *)arg1)->text_selected(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  int arg2 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Help_View_copy", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_copy" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_View_copy" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      result = (int)(arg1)->copy(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_scrollbar_size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 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_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_scrollbar_size" "', argument " "1"" of type '" "Fl_Help_View const *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  {
    try {
      result = (int)((Fl_Help_View const *)arg1)->scrollbar_size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_scrollbar_size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 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_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_scrollbar_size" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_View_scrollbar_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->scrollbar_size(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_scrollbar_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Help_View_scrollbar_size", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Help_View_scrollbar_size__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Help_View_scrollbar_size__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Help_View_scrollbar_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Help_View::scrollbar_size() const\n"
    "    Fl_Help_View::scrollbar_size(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_scrollbar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Scrollbar *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_scrollbar" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  {
    try {
      result = (Fl_Scrollbar *)(arg1)->scrollbar(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Scrollbar, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_hscrollbar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Scrollbar *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_hscrollbar" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  {
    try {
      result = (Fl_Scrollbar *)(arg1)->hscrollbar(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Scrollbar, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 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, "Fl_Help_View_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_init_type" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Help_View_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Help_View_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_link__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 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_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_View_link" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(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];
  {
    try {
      Fl_Help_View_link__SWIG_1(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_link(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Help_View_link", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Help_View_link__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Help_View_link__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Help_View_link'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Help_View::link(Fl_Help_Func *)\n"
    "    Fl_Help_View::link(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Help_View(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Help_View, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Help_View" "', argument " "1"" of type '" "Fl_Help_View *""'"); 
  }
  arg1 = (Fl_Help_View *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Hold_Browser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Hold_Browser *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Hold_Browser", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Hold_Browser" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Hold_Browser" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Hold_Browser" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Hold_Browser" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Hold_Browser" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Hold_Browser *)new SwigDirector_Fl_Hold_Browser(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Hold_Browser *)new Fl_Hold_Browser(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Hold_Browser, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 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, "Fl_Hold_Browser_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hold_Browser_init_type" "', argument " "1"" of type '" "Fl_Hold_Browser *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Hold_Browser_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Hold_Browser_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Hold_Browser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Hold_Browser" "', argument " "1"" of type '" "Fl_Hold_Browser *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Hold_Browser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Hold_Browser" "', argument " "1"" of type '" "Fl_Hold_Browser *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hold_Browser_draw" "', argument " "1"" of type '" "Fl_Hold_Browser *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_first(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hold_Browser_item_first" "', argument " "1"" of type '" "Fl_Hold_Browser const *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_first"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_first");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Hold_Browser const *)darg)->item_firstSwigPublic();
        } else {
          result = (void *)((SwigDirector_Fl_Hold_Browser const *)darg)->item_first();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Hold_Browser_item_next", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hold_Browser_item_next" "', argument " "1"" of type '" "Fl_Hold_Browser const *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(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 '" "Fl_Hold_Browser_item_next" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_next"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_next");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Hold_Browser const *)darg)->item_nextSwigPublic(arg2);
        } else {
          result = (void *)((SwigDirector_Fl_Hold_Browser const *)darg)->item_next(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_prev(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Hold_Browser_item_prev", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hold_Browser_item_prev" "', argument " "1"" of type '" "Fl_Hold_Browser const *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(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 '" "Fl_Hold_Browser_item_prev" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_prev"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_prev");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Hold_Browser const *)darg)->item_prevSwigPublic(arg2);
        } else {
          result = (void *)((SwigDirector_Fl_Hold_Browser const *)darg)->item_prev(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_last(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hold_Browser_item_last" "', argument " "1"" of type '" "Fl_Hold_Browser const *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_last"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_last");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Hold_Browser const *)darg)->item_lastSwigPublic();
        } else {
          result = (void *)((SwigDirector_Fl_Hold_Browser const *)darg)->item_last();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Hold_Browser_item_height", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hold_Browser_item_height" "', argument " "1"" of type '" "Fl_Hold_Browser const *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(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 '" "Fl_Hold_Browser_item_height" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Hold_Browser const *)darg)->item_heightSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Hold_Browser const *)darg)->item_height(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_width(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Hold_Browser_item_width", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hold_Browser_item_width" "', argument " "1"" of type '" "Fl_Hold_Browser const *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(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 '" "Fl_Hold_Browser_item_width" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_width"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_width");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Hold_Browser const *)darg)->item_widthSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Hold_Browser const *)darg)->item_width(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_quick_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Hold_Browser_item_quick_height", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hold_Browser_item_quick_height" "', argument " "1"" of type '" "Fl_Hold_Browser const *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(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 '" "Fl_Hold_Browser_item_quick_height" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_quick_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_quick_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Hold_Browser const *)darg)->item_quick_heightSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Hold_Browser const *)darg)->item_quick_height(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Hold_Browser_item_draw", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hold_Browser_item_draw" "', argument " "1"" of type '" "Fl_Hold_Browser const *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(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 '" "Fl_Hold_Browser_item_draw" "', 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 '" "Fl_Hold_Browser_item_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Hold_Browser_item_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Hold_Browser_item_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Hold_Browser_item_draw" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    {
      try {
        if (upcall) {
          ((SwigDirector_Fl_Hold_Browser const *)darg)->item_drawSwigPublic(arg2,arg3,arg4,arg5,arg6);
        } else {
          ((SwigDirector_Fl_Hold_Browser const *)darg)->item_draw(arg2,arg3,arg4,arg5,arg6);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_text(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Hold_Browser_item_text", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hold_Browser_item_text" "', argument " "1"" of type '" "Fl_Hold_Browser const *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(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 '" "Fl_Hold_Browser_item_text" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_text"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_text");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (char *)((SwigDirector_Fl_Hold_Browser const *)darg)->item_textSwigPublic(arg2);
        } else {
          result = (char *)((SwigDirector_Fl_Hold_Browser const *)darg)->item_text(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (director) {
    director->swig_release_ownership(SWIG_as_voidptr(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Hold_Browser_item_swap", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hold_Browser_item_swap" "', argument " "1"" of type '" "Fl_Hold_Browser *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(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 '" "Fl_Hold_Browser_item_swap" "', argument " "2"" of type '" "void *""'"); 
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Hold_Browser_item_swap" "', argument " "3"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_swap"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_swap");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->item_swapSwigPublic(arg2,arg3);
        } else {
          (darg)->item_swap(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_at(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Hold_Browser_item_at", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hold_Browser_item_at" "', argument " "1"" of type '" "Fl_Hold_Browser const *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Hold_Browser_item_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_at"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_at");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Hold_Browser const *)darg)->item_atSwigPublic(arg2);
        } else {
          result = (void *)((SwigDirector_Fl_Hold_Browser const *)darg)->item_at(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_full_width(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hold_Browser_full_width" "', argument " "1"" of type '" "Fl_Hold_Browser const *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("full_width"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member full_width");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Hold_Browser const *)darg)->full_widthSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Hold_Browser const *)darg)->full_width();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_full_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hold_Browser_full_height" "', argument " "1"" of type '" "Fl_Hold_Browser const *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("full_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member full_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Hold_Browser const *)darg)->full_heightSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Hold_Browser const *)darg)->full_height();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_incr_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hold_Browser_incr_height" "', argument " "1"" of type '" "Fl_Hold_Browser const *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("incr_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member incr_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Hold_Browser const *)darg)->incr_heightSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Hold_Browser const *)darg)->incr_height();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_select(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Hold_Browser_item_select", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hold_Browser_item_select" "', argument " "1"" of type '" "Fl_Hold_Browser *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(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 '" "Fl_Hold_Browser_item_select" "', 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 '" "Fl_Hold_Browser_item_select" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_select"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_select");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->item_selectSwigPublic(arg2,arg3);
        } else {
          (darg)->item_select(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_selected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Hold_Browser_item_selected", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hold_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hold_Browser_item_selected" "', argument " "1"" of type '" "Fl_Hold_Browser const *""'"); 
  }
  arg1 = (Fl_Hold_Browser *)(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 '" "Fl_Hold_Browser_item_selected" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_selected"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_selected");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Hold_Browser const *)darg)->item_selectedSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Hold_Browser const *)darg)->item_selected(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Hor_Fill_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Hor_Fill_Slider *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Hor_Fill_Slider", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Hor_Fill_Slider" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Hor_Fill_Slider" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Hor_Fill_Slider" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Hor_Fill_Slider" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Hor_Fill_Slider" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Hor_Fill_Slider *)new SwigDirector_Fl_Hor_Fill_Slider(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Hor_Fill_Slider *)new Fl_Hor_Fill_Slider(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Hor_Fill_Slider, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hor_Fill_Slider_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Fill_Slider *arg1 = (Fl_Hor_Fill_Slider *) 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, "Fl_Hor_Fill_Slider_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hor_Fill_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hor_Fill_Slider_init_type" "', argument " "1"" of type '" "Fl_Hor_Fill_Slider *""'"); 
  }
  arg1 = (Fl_Hor_Fill_Slider *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Hor_Fill_Slider_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Hor_Fill_Slider_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Hor_Fill_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Fill_Slider *arg1 = (Fl_Hor_Fill_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hor_Fill_Slider, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Hor_Fill_Slider" "', argument " "1"" of type '" "Fl_Hor_Fill_Slider *""'"); 
  }
  arg1 = (Fl_Hor_Fill_Slider *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Hor_Fill_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Fill_Slider *arg1 = (Fl_Hor_Fill_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hor_Fill_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Hor_Fill_Slider" "', argument " "1"" of type '" "Fl_Hor_Fill_Slider *""'"); 
  }
  arg1 = (Fl_Hor_Fill_Slider *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hor_Fill_Slider_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Fill_Slider *arg1 = (Fl_Hor_Fill_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hor_Fill_Slider *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hor_Fill_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hor_Fill_Slider_draw" "', argument " "1"" of type '" "Fl_Hor_Fill_Slider *""'"); 
  }
  arg1 = (Fl_Hor_Fill_Slider *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hor_Fill_Slider *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Hor_Nice_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Hor_Nice_Slider *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Hor_Nice_Slider", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Hor_Nice_Slider" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Hor_Nice_Slider" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Hor_Nice_Slider" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Hor_Nice_Slider" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Hor_Nice_Slider" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Hor_Nice_Slider *)new SwigDirector_Fl_Hor_Nice_Slider(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Hor_Nice_Slider *)new Fl_Hor_Nice_Slider(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Hor_Nice_Slider, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hor_Nice_Slider_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Nice_Slider *arg1 = (Fl_Hor_Nice_Slider *) 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, "Fl_Hor_Nice_Slider_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hor_Nice_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hor_Nice_Slider_init_type" "', argument " "1"" of type '" "Fl_Hor_Nice_Slider *""'"); 
  }
  arg1 = (Fl_Hor_Nice_Slider *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Hor_Nice_Slider_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Hor_Nice_Slider_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Hor_Nice_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Nice_Slider *arg1 = (Fl_Hor_Nice_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hor_Nice_Slider, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Hor_Nice_Slider" "', argument " "1"" of type '" "Fl_Hor_Nice_Slider *""'"); 
  }
  arg1 = (Fl_Hor_Nice_Slider *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Hor_Nice_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Nice_Slider *arg1 = (Fl_Hor_Nice_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hor_Nice_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Hor_Nice_Slider" "', argument " "1"" of type '" "Fl_Hor_Nice_Slider *""'"); 
  }
  arg1 = (Fl_Hor_Nice_Slider *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hor_Nice_Slider_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Nice_Slider *arg1 = (Fl_Hor_Nice_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hor_Nice_Slider *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hor_Nice_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hor_Nice_Slider_draw" "', argument " "1"" of type '" "Fl_Hor_Nice_Slider *""'"); 
  }
  arg1 = (Fl_Hor_Nice_Slider *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hor_Nice_Slider *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Hor_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Hor_Slider *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Hor_Slider", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Hor_Slider" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Hor_Slider" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Hor_Slider" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Hor_Slider" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Hor_Slider" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Hor_Slider *)new SwigDirector_Fl_Hor_Slider(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Hor_Slider *)new Fl_Hor_Slider(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Hor_Slider, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hor_Slider_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Slider *arg1 = (Fl_Hor_Slider *) 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, "Fl_Hor_Slider_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hor_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hor_Slider_init_type" "', argument " "1"" of type '" "Fl_Hor_Slider *""'"); 
  }
  arg1 = (Fl_Hor_Slider *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Hor_Slider_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Hor_Slider_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Hor_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Slider *arg1 = (Fl_Hor_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hor_Slider, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Hor_Slider" "', argument " "1"" of type '" "Fl_Hor_Slider *""'"); 
  }
  arg1 = (Fl_Hor_Slider *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Hor_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Slider *arg1 = (Fl_Hor_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hor_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Hor_Slider" "', argument " "1"" of type '" "Fl_Hor_Slider *""'"); 
  }
  arg1 = (Fl_Hor_Slider *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hor_Slider_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Slider *arg1 = (Fl_Hor_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hor_Slider *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hor_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hor_Slider_draw" "', argument " "1"" of type '" "Fl_Hor_Slider *""'"); 
  }
  arg1 = (Fl_Hor_Slider *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hor_Slider *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Value_Slider_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Value_Slider *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Slider_draw" "', argument " "1"" of type '" "Fl_Value_Slider *""'"); 
  }
  arg1 = (Fl_Value_Slider *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Value_Slider *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Value_Slider_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Slider_handle" "', argument " "1"" of type '" "Fl_Value_Slider *""'"); 
  }
  arg1 = (Fl_Value_Slider *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Slider_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Value_Slider::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Value_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Value_Slider *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Value_Slider", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Value_Slider" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Value_Slider" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Value_Slider" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Value_Slider" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Value_Slider" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Value_Slider *)new SwigDirector_Fl_Value_Slider(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Value_Slider *)new Fl_Value_Slider(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Value_Slider, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_textfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Slider_textfont" "', argument " "1"" of type '" "Fl_Value_Slider const *""'"); 
  }
  arg1 = (Fl_Value_Slider *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Value_Slider const *)arg1)->textfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_textfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 0 ;
  Fl_Font 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_Fl_Value_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Slider_textfont" "', argument " "1"" of type '" "Fl_Value_Slider *""'"); 
  }
  arg1 = (Fl_Value_Slider *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Slider_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->textfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_textfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Value_Slider_textfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Value_Slider_textfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Value_Slider_textfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Value_Slider_textfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Value_Slider::textfont() const\n"
    "    Fl_Value_Slider::textfont(Fl_Font)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_textsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Slider_textsize" "', argument " "1"" of type '" "Fl_Value_Slider const *""'"); 
  }
  arg1 = (Fl_Value_Slider *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Value_Slider const *)arg1)->textsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_textsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 0 ;
  Fl_Fontsize 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_Fl_Value_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Slider_textsize" "', argument " "1"" of type '" "Fl_Value_Slider *""'"); 
  }
  arg1 = (Fl_Value_Slider *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Slider_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->textsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_textsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Value_Slider_textsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Value_Slider_textsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Value_Slider_textsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Value_Slider_textsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Value_Slider::textsize() const\n"
    "    Fl_Value_Slider::textsize(Fl_Fontsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_textcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Slider_textcolor" "', argument " "1"" of type '" "Fl_Value_Slider const *""'"); 
  }
  arg1 = (Fl_Value_Slider *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Value_Slider const *)arg1)->textcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_textcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Slider_textcolor" "', argument " "1"" of type '" "Fl_Value_Slider *""'"); 
  }
  arg1 = (Fl_Value_Slider *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Slider_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->textcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_textcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Value_Slider_textcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Value_Slider_textcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Value_Slider_textcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Value_Slider_textcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Value_Slider::textcolor() const\n"
    "    Fl_Value_Slider::textcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_value_width__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 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_Fl_Value_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Slider_value_width" "', argument " "1"" of type '" "Fl_Value_Slider *""'"); 
  }
  arg1 = (Fl_Value_Slider *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Slider_value_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->value_width(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_value_width__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 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_Fl_Value_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Slider_value_width" "', argument " "1"" of type '" "Fl_Value_Slider const *""'"); 
  }
  arg1 = (Fl_Value_Slider *)(argp1);
  {
    try {
      result = (int)((Fl_Value_Slider const *)arg1)->value_width(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_value_width(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Value_Slider_value_width", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Value_Slider_value_width__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Value_Slider_value_width__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Value_Slider_value_width'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Value_Slider::value_width(int)\n"
    "    Fl_Value_Slider::value_width() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_value_height__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 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_Fl_Value_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Slider_value_height" "', argument " "1"" of type '" "Fl_Value_Slider *""'"); 
  }
  arg1 = (Fl_Value_Slider *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Slider_value_height" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->value_height(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_value_height__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 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_Fl_Value_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Slider_value_height" "', argument " "1"" of type '" "Fl_Value_Slider const *""'"); 
  }
  arg1 = (Fl_Value_Slider *)(argp1);
  {
    try {
      result = (int)((Fl_Value_Slider const *)arg1)->value_height(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_value_height(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Value_Slider_value_height", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Value_Slider_value_height__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Value_Slider_value_height__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Value_Slider_value_height'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Value_Slider::value_height(int)\n"
    "    Fl_Value_Slider::value_height() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 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, "Fl_Value_Slider_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Slider_init_type" "', argument " "1"" of type '" "Fl_Value_Slider *""'"); 
  }
  arg1 = (Fl_Value_Slider *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Value_Slider_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Value_Slider_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Value_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Slider, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Value_Slider" "', argument " "1"" of type '" "Fl_Value_Slider *""'"); 
  }
  arg1 = (Fl_Value_Slider *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Value_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Value_Slider" "', argument " "1"" of type '" "Fl_Value_Slider *""'"); 
  }
  arg1 = (Fl_Value_Slider *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Hor_Value_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Hor_Value_Slider *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Hor_Value_Slider", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Hor_Value_Slider" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Hor_Value_Slider" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Hor_Value_Slider" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Hor_Value_Slider" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Hor_Value_Slider" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Hor_Value_Slider *)new SwigDirector_Fl_Hor_Value_Slider(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Hor_Value_Slider *)new Fl_Hor_Value_Slider(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Hor_Value_Slider, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hor_Value_Slider_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Value_Slider *arg1 = (Fl_Hor_Value_Slider *) 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, "Fl_Hor_Value_Slider_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hor_Value_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hor_Value_Slider_init_type" "', argument " "1"" of type '" "Fl_Hor_Value_Slider *""'"); 
  }
  arg1 = (Fl_Hor_Value_Slider *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Hor_Value_Slider_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Hor_Value_Slider_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Hor_Value_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Value_Slider *arg1 = (Fl_Hor_Value_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hor_Value_Slider, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Hor_Value_Slider" "', argument " "1"" of type '" "Fl_Hor_Value_Slider *""'"); 
  }
  arg1 = (Fl_Hor_Value_Slider *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Hor_Value_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Value_Slider *arg1 = (Fl_Hor_Value_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hor_Value_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Hor_Value_Slider" "', argument " "1"" of type '" "Fl_Hor_Value_Slider *""'"); 
  }
  arg1 = (Fl_Hor_Value_Slider *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hor_Value_Slider_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Value_Slider *arg1 = (Fl_Hor_Value_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hor_Value_Slider *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Hor_Value_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Hor_Value_Slider_draw" "', argument " "1"" of type '" "Fl_Hor_Value_Slider *""'"); 
  }
  arg1 = (Fl_Hor_Value_Slider *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hor_Value_Slider *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Int_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Int_Input *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Int_Input", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Int_Input" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Int_Input" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Int_Input" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Int_Input" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Int_Input" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Int_Input *)new SwigDirector_Fl_Int_Input(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Int_Input *)new Fl_Int_Input(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Int_Input, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Int_Input_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Int_Input *arg1 = (Fl_Int_Input *) 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, "Fl_Int_Input_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Int_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Int_Input_init_type" "', argument " "1"" of type '" "Fl_Int_Input *""'"); 
  }
  arg1 = (Fl_Int_Input *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Int_Input_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Int_Input_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Int_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Int_Input *arg1 = (Fl_Int_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Int_Input, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Int_Input" "', argument " "1"" of type '" "Fl_Int_Input *""'"); 
  }
  arg1 = (Fl_Int_Input *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Int_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Int_Input *arg1 = (Fl_Int_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Int_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Int_Input" "', argument " "1"" of type '" "Fl_Int_Input *""'"); 
  }
  arg1 = (Fl_Int_Input *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Int_Input_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Int_Input *arg1 = (Fl_Int_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Int_Input *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Int_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Int_Input_draw" "', argument " "1"" of type '" "Fl_Int_Input *""'"); 
  }
  arg1 = (Fl_Int_Input *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Int_Input *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Input_Choice_inp_x(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Input_Choice *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_inp_x" "', argument " "1"" of type '" "Fl_Input_Choice const *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("inp_x"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member inp_x");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Input_Choice *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Input_Choice const *)darg)->inp_xSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Input_Choice const *)darg)->inp_x();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_inp_y(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Input_Choice *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_inp_y" "', argument " "1"" of type '" "Fl_Input_Choice const *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("inp_y"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member inp_y");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Input_Choice *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Input_Choice const *)darg)->inp_ySwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Input_Choice const *)darg)->inp_y();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_inp_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Input_Choice *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_inp_w" "', argument " "1"" of type '" "Fl_Input_Choice const *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("inp_w"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member inp_w");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Input_Choice *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Input_Choice const *)darg)->inp_wSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Input_Choice const *)darg)->inp_w();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_inp_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Input_Choice *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_inp_h" "', argument " "1"" of type '" "Fl_Input_Choice const *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("inp_h"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member inp_h");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Input_Choice *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Input_Choice const *)darg)->inp_hSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Input_Choice const *)darg)->inp_h();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_menu_x(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Input_Choice *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_menu_x" "', argument " "1"" of type '" "Fl_Input_Choice const *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("menu_x"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member menu_x");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Input_Choice *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Input_Choice const *)darg)->menu_xSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Input_Choice const *)darg)->menu_x();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_menu_y(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Input_Choice *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_menu_y" "', argument " "1"" of type '" "Fl_Input_Choice const *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("menu_y"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member menu_y");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Input_Choice *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Input_Choice const *)darg)->menu_ySwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Input_Choice const *)darg)->menu_y();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_menu_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Input_Choice *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_menu_w" "', argument " "1"" of type '" "Fl_Input_Choice const *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("menu_w"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member menu_w");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Input_Choice *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Input_Choice const *)darg)->menu_wSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Input_Choice const *)darg)->menu_w();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_menu_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Input_Choice *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_menu_h" "', argument " "1"" of type '" "Fl_Input_Choice const *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("menu_h"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member menu_h");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Input_Choice *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Input_Choice const *)darg)->menu_hSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Input_Choice const *)darg)->menu_h();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Input_Choice *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_draw" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Input_Choice *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Input_Choice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Input_Choice *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Input_Choice", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Input_Choice" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Input_Choice" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Input_Choice" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Input_Choice" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Input_Choice" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Input_Choice *)new SwigDirector_Fl_Input_Choice(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Input_Choice *)new Fl_Input_Choice(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Input_Choice, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Input_Choice_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_resize" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input_Choice_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Input_Choice_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Input_Choice_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Input_Choice_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Input_Choice::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_add(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 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, "Fl_Input_Choice_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_add" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Input_Choice_add" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->add((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_changed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 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_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_changed" "', argument " "1"" of type '" "Fl_Input_Choice const *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  {
    try {
      result = (int)((Fl_Input_Choice const *)arg1)->changed(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_clear_changed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_clear_changed" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  {
    try {
      (arg1)->clear_changed(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_set_changed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_set_changed" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  {
    try {
      (arg1)->set_changed(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_clear" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_down_box__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Boxtype result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_down_box" "', argument " "1"" of type '" "Fl_Input_Choice const *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  {
    try {
      result = (Fl_Boxtype)((Fl_Input_Choice const *)arg1)->down_box(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_down_box__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  Fl_Boxtype 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_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_down_box" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input_Choice_down_box" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = (Fl_Boxtype)(val2);
  {
    try {
      (arg1)->down_box(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_down_box(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input_Choice_down_box", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input_Choice_down_box__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input_Choice_down_box__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input_Choice_down_box'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_Choice::down_box() const\n"
    "    Fl_Input_Choice::down_box(Fl_Boxtype)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_menu__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_menu" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  {
    try {
      result = (Fl_Menu_Item *)(arg1)->menu(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_menu__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  Fl_Menu_Item *arg2 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_menu" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Input_Choice_menu" "', argument " "2"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg2 = (Fl_Menu_Item *)(argp2);
  {
    try {
      (arg1)->menu((Fl_Menu_Item const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_menu(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input_Choice_menu", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input_Choice_menu__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input_Choice_menu__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input_Choice_menu'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_Choice::menu()\n"
    "    Fl_Input_Choice::menu(Fl_Menu_Item const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_textcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_textcolor" "', argument " "1"" of type '" "Fl_Input_Choice const *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Input_Choice const *)arg1)->textcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_textcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_textcolor" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input_Choice_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->textcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_textcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input_Choice_textcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input_Choice_textcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input_Choice_textcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input_Choice_textcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_Choice::textcolor() const\n"
    "    Fl_Input_Choice::textcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_textfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_textfont" "', argument " "1"" of type '" "Fl_Input_Choice const *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Input_Choice const *)arg1)->textfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_textfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  Fl_Font 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_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_textfont" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input_Choice_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->textfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_textfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input_Choice_textfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input_Choice_textfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input_Choice_textfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input_Choice_textfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_Choice::textfont() const\n"
    "    Fl_Input_Choice::textfont(Fl_Font)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_textsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_textsize" "', argument " "1"" of type '" "Fl_Input_Choice const *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Input_Choice const *)arg1)->textsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_textsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  Fl_Fontsize 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_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_textsize" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input_Choice_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->textsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_textsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input_Choice_textsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input_Choice_textsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input_Choice_textsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input_Choice_textsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_Choice::textsize() const\n"
    "    Fl_Input_Choice::textsize(Fl_Fontsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_value" "', argument " "1"" of type '" "Fl_Input_Choice const *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  {
    try {
      result = (char *)((Fl_Input_Choice const *)arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_value" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Input_Choice_value" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->value((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 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_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_value" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input_Choice_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->value(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Input_Choice_value", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Input_Choice_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_Fl_Input_Choice_value__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Input_Choice_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Input_Choice_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_Choice::value() const\n"
    "    Fl_Input_Choice::value(char const *)\n"
    "    Fl_Input_Choice::value(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_update_menubutton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 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_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_update_menubutton" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  {
    try {
      result = (int)(arg1)->update_menubutton(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_menubutton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Menu_Button *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_menubutton" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  {
    try {
      result = (Fl_Menu_Button *)(arg1)->menubutton(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Button, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Input *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_input" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  {
    try {
      result = (Fl_Input *)(arg1)->input(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Input, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 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, "Fl_Input_Choice_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input_Choice_init_type" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Input_Choice_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Input_Choice_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Input_Choice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Input_Choice" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Input_Choice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Input_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Input_Choice" "', argument " "1"" of type '" "Fl_Input_Choice *""'"); 
  }
  arg1 = (Fl_Input_Choice *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_JPEG_Image__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  Fl_JPEG_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_JPEG_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_JPEG_Image *)new SwigDirector_Fl_JPEG_Image(arg1,(char const *)arg2); 
      } else {
        result = (Fl_JPEG_Image *)new Fl_JPEG_Image((char const *)arg2); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_JPEG_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_JPEG_Image__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  unsigned char *arg3 = (unsigned char *) 0 ;
  int arg4 = (int) -1 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Fl_JPEG_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_JPEG_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    /* Check if the input support the buffer protocol */
    Py_buffer view;
    const void * buffer;
    int failure = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_CONTIG_RO);
    if (!failure) {
      // work with array object
      buffer = view.buf;
      PyBuffer_Release(&view);
      arg3 = (uchar *) buffer;
    } else {
      // work with list object
      // clear the error from PyObject_GetBuffer
      PyErr_Clear();
      buffer=0;
      /* Check if is a list */
      if (PyList_Check(swig_obj[2])) {
        Py_ssize_t size = PyList_Size(swig_obj[2]);
        int i = 0;
        arg3 = (uchar *) malloc((size+1)*sizeof(char));
        for (i = 0; i < size; i++) {
          PyObject *o = 	PyList_GetItem(swig_obj[2],i);
          if (PyInt_Check(o))
          arg3[i] = (uchar)PyInt_AsLong(o);
          else {
            PyErr_SetString(PyExc_TypeError,"list must contain ints");
            free(arg3);
            return NULL;
          }
        }
        arg3[i] = 0;
      } else {
        PyErr_SetString(PyExc_TypeError,"not a list or does not support single-segment readable buffer interface");
        return NULL;
      }
    }
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_JPEG_Image" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_JPEG_Image *)new SwigDirector_Fl_JPEG_Image(arg1,(char const *)arg2,(unsigned char const *)arg3,arg4); 
      } else {
        result = (Fl_JPEG_Image *)new Fl_JPEG_Image((char const *)arg2,(unsigned char const *)arg3,arg4); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_JPEG_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_JPEG_Image(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_JPEG_Image", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Fl_JPEG_Image__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 3) && (argc <= 4)) {
    PyObject *retobj = _wrap_new_Fl_JPEG_Image__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_JPEG_Image'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_JPEG_Image::Fl_JPEG_Image(char const *)\n"
    "    Fl_JPEG_Image::Fl_JPEG_Image(PyObject *,char const *,unsigned char const *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_JPEG_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_JPEG_Image *arg1 = (Fl_JPEG_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_JPEG_Image, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_JPEG_Image" "', argument " "1"" of type '" "Fl_JPEG_Image *""'"); 
  }
  arg1 = (Fl_JPEG_Image *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_JPEG_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_JPEG_Image *arg1 = (Fl_JPEG_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_JPEG_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_JPEG_Image" "', argument " "1"" of type '" "Fl_JPEG_Image *""'"); 
  }
  arg1 = (Fl_JPEG_Image *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Line_Dial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Line_Dial *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Line_Dial", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Line_Dial" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Line_Dial" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Line_Dial" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Line_Dial" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Line_Dial" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Line_Dial *)new SwigDirector_Fl_Line_Dial(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Line_Dial *)new Fl_Line_Dial(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Line_Dial, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Line_Dial_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Line_Dial *arg1 = (Fl_Line_Dial *) 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, "Fl_Line_Dial_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Line_Dial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Line_Dial_init_type" "', argument " "1"" of type '" "Fl_Line_Dial *""'"); 
  }
  arg1 = (Fl_Line_Dial *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Line_Dial_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Line_Dial_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Line_Dial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Line_Dial *arg1 = (Fl_Line_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Line_Dial, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Line_Dial" "', argument " "1"" of type '" "Fl_Line_Dial *""'"); 
  }
  arg1 = (Fl_Line_Dial *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Line_Dial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Line_Dial *arg1 = (Fl_Line_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Line_Dial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Line_Dial" "', argument " "1"" of type '" "Fl_Line_Dial *""'"); 
  }
  arg1 = (Fl_Line_Dial *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Line_Dial_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Line_Dial *arg1 = (Fl_Line_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Line_Dial *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Line_Dial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Line_Dial_draw" "', argument " "1"" of type '" "Fl_Line_Dial *""'"); 
  }
  arg1 = (Fl_Line_Dial *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Line_Dial *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Menu_Bar_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Bar *arg1 = (Fl_Menu_Bar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Menu_Bar *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Bar_draw" "', argument " "1"" of type '" "Fl_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Menu_Bar *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Menu_Bar *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Bar_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Bar *arg1 = (Fl_Menu_Bar *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Menu_Bar_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Bar_handle" "', argument " "1"" of type '" "Fl_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Menu_Bar *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Bar_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Menu_Bar::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Menu_Bar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Menu_Bar *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Menu_Bar", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Menu_Bar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Menu_Bar" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Menu_Bar" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Menu_Bar" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Menu_Bar" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Menu_Bar *)new SwigDirector_Fl_Menu_Bar(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Menu_Bar *)new Fl_Menu_Bar(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Bar, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Bar_update(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Bar *arg1 = (Fl_Menu_Bar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Bar_update" "', argument " "1"" of type '" "Fl_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Menu_Bar *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Menu_Bar::update();
        } else {
          (arg1)->update();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Bar_play_menu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Bar *arg1 = (Fl_Menu_Bar *) 0 ;
  Fl_Menu_Item *arg2 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Menu_Bar_play_menu", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Bar_play_menu" "', argument " "1"" of type '" "Fl_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Menu_Bar *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu_Bar_play_menu" "', argument " "2"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg2 = (Fl_Menu_Item *)(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Menu_Bar::play_menu((Fl_Menu_Item const *)arg2);
        } else {
          (arg1)->play_menu((Fl_Menu_Item const *)arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Bar_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Bar *arg1 = (Fl_Menu_Bar *) 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, "Fl_Menu_Bar_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Bar_init_type" "', argument " "1"" of type '" "Fl_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Menu_Bar *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu_Bar_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Menu_Bar_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Menu_Bar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Bar *arg1 = (Fl_Menu_Bar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Bar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Menu_Bar" "', argument " "1"" of type '" "Fl_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Menu_Bar *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Menu_Bar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Bar *arg1 = (Fl_Menu_Bar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Menu_Bar" "', argument " "1"" of type '" "Fl_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Menu_Bar *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Menu_Button_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Button *arg1 = (Fl_Menu_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Menu_Button *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Button_draw" "', argument " "1"" of type '" "Fl_Menu_Button *""'"); 
  }
  arg1 = (Fl_Menu_Button *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Menu_Button *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Button_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Button *arg1 = (Fl_Menu_Button *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Menu_Button_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Button_handle" "', argument " "1"" of type '" "Fl_Menu_Button *""'"); 
  }
  arg1 = (Fl_Menu_Button *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Button_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Menu_Button::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Button_popup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Button *arg1 = (Fl_Menu_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Button_popup" "', argument " "1"" of type '" "Fl_Menu_Button *""'"); 
  }
  arg1 = (Fl_Menu_Button *)(argp1);
  {
    try {
      result = (Fl_Menu_Item *)(arg1)->popup(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Menu_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Menu_Button *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Menu_Button", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Menu_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Menu_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Menu_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Menu_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Menu_Button" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Menu_Button *)new SwigDirector_Fl_Menu_Button(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Menu_Button *)new Fl_Menu_Button(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Button, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Button_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Button *arg1 = (Fl_Menu_Button *) 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, "Fl_Menu_Button_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Button_init_type" "', argument " "1"" of type '" "Fl_Menu_Button *""'"); 
  }
  arg1 = (Fl_Menu_Button *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu_Button_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Menu_Button_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Menu_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Button *arg1 = (Fl_Menu_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Button, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Menu_Button" "', argument " "1"" of type '" "Fl_Menu_Button *""'"); 
  }
  arg1 = (Fl_Menu_Button *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Menu_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Button *arg1 = (Fl_Menu_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Menu_Button" "', argument " "1"" of type '" "Fl_Menu_Button *""'"); 
  }
  arg1 = (Fl_Menu_Button *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Menu_Item_next__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  int arg2 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_next" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_next" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      result = (Fl_Menu_Item *)((Fl_Menu_Item const *)arg1)->next(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_next__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  int arg2 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_next" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_next" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      result = (Fl_Menu_Item *)(arg1)->next(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_next(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_next", 0, 2, argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    PyObject *retobj = _wrap_Fl_Menu_Item_next__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 1) && (argc <= 2)) {
    PyObject *retobj = _wrap_Fl_Menu_Item_next__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu_Item_next'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_Item::next(int) const\n"
    "    Fl_Menu_Item::next(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_first__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_first" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (Fl_Menu_Item *)((Fl_Menu_Item const *)arg1)->first(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_first__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_first" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (Fl_Menu_Item *)(arg1)->first(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_first(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_first", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu_Item_first__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu_Item_first__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu_Item_first'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_Item::first() const\n"
    "    Fl_Menu_Item::first()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_label__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_label" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (char *)((Fl_Menu_Item const *)arg1)->label(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_label__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_label" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu_Item_label" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->label((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_label__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Labeltype arg2 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_label" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_label" "', argument " "2"" of type '" "Fl_Labeltype""'");
  } 
  arg2 = (Fl_Labeltype)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Menu_Item_label" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      (arg1)->label(arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_label(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_label", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu_Item_label__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu_Item_label__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Menu_Item_label__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu_Item_label'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_Item::label() const\n"
    "    Fl_Menu_Item::label(char const *)\n"
    "    Fl_Menu_Item::label(Fl_Labeltype,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_multi_label(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Multi_Label *arg2 = (Fl_Multi_Label *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_multi_label", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_multi_label" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Multi_Label, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu_Item_multi_label" "', argument " "2"" of type '" "Fl_Multi_Label const *""'"); 
  }
  arg2 = (Fl_Multi_Label *)(argp2);
  {
    try {
      (arg1)->multi_label((Fl_Multi_Label const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_image_label(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Image *arg2 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_image_label", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_image_label" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu_Item_image_label" "', argument " "2"" of type '" "Fl_Image const *""'"); 
  }
  arg2 = (Fl_Image *)(argp2);
  {
    try {
      (arg1)->image_label((Fl_Image const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labeltype__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Labeltype result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_labeltype" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (Fl_Labeltype)((Fl_Menu_Item const *)arg1)->labeltype(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labeltype__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Labeltype 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_labeltype" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_labeltype" "', argument " "2"" of type '" "Fl_Labeltype""'");
  } 
  arg2 = (Fl_Labeltype)(val2);
  {
    try {
      (arg1)->labeltype(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labeltype(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_labeltype", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu_Item_labeltype__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu_Item_labeltype__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu_Item_labeltype'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_Item::labeltype() const\n"
    "    Fl_Menu_Item::labeltype(Fl_Labeltype)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labelcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_labelcolor" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Menu_Item const *)arg1)->labelcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labelcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_labelcolor" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_labelcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->labelcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labelcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_labelcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu_Item_labelcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu_Item_labelcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu_Item_labelcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_Item::labelcolor() const\n"
    "    Fl_Menu_Item::labelcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labelfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_labelfont" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Menu_Item const *)arg1)->labelfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labelfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Font 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_labelfont" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_labelfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->labelfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labelfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_labelfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu_Item_labelfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu_Item_labelfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu_Item_labelfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_Item::labelfont() const\n"
    "    Fl_Menu_Item::labelfont(Fl_Font)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labelsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_labelsize" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Menu_Item const *)arg1)->labelsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labelsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Fontsize 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_labelsize" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_labelsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->labelsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labelsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_labelsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu_Item_labelsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu_Item_labelsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu_Item_labelsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_Item::labelsize() const\n"
    "    Fl_Menu_Item::labelsize(Fl_Fontsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_callback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Callback *arg2 = (Fl_Callback *) 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_callback" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Menu_Item_callback" "', argument " "2"" of type '" "Fl_Callback *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Menu_Item_callback" "', argument " "3"" of type '" "void *""'"); 
  }
  {
    try {
      (arg1)->callback(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_callback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Callback *arg2 = (Fl_Callback *) 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_callback" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Menu_Item_callback" "', argument " "2"" of type '" "Fl_Callback *""'"); 
    }
  }
  {
    try {
      (arg1)->callback(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_callback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Callback0 *arg2 = (Fl_Callback0 *) 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_callback" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_Fl_Widget__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Menu_Item_callback" "', argument " "2"" of type '" "Fl_Callback0 *""'"); 
    }
  }
  {
    try {
      (arg1)->callback(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_callback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Callback1 *arg2 = (Fl_Callback1 *) 0 ;
  long arg3 = (long) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_callback" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_Fl_Widget_long__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Menu_Item_callback" "', argument " "2"" of type '" "Fl_Callback1 *""'"); 
    }
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu_Item_callback" "', argument " "3"" of type '" "long""'");
    } 
    arg3 = (long)(val3);
  }
  {
    try {
      (arg1)->callback(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_argument__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_argument" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (long)((Fl_Menu_Item const *)arg1)->argument(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long((long)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_argument__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_argument" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_argument" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = (long)(val2);
  {
    try {
      (arg1)->argument(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_argument(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_argument", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu_Item_argument__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu_Item_argument__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu_Item_argument'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_Item::argument() const\n"
    "    Fl_Menu_Item::argument(long)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_shortcut__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_shortcut" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Menu_Item const *)arg1)->shortcut(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_shortcut__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_shortcut" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_shortcut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->shortcut(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_shortcut(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_shortcut", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu_Item_shortcut__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu_Item_shortcut__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu_Item_shortcut'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_Item::shortcut() const\n"
    "    Fl_Menu_Item::shortcut(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_submenu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_submenu" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Menu_Item const *)arg1)->submenu(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_checkbox(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_checkbox" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Menu_Item const *)arg1)->checkbox(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_radio(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_radio" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Menu_Item const *)arg1)->radio(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_value" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Menu_Item const *)arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_value" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->value(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_value", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu_Item_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu_Item_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu_Item_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_Item::value() const\n"
    "    Fl_Menu_Item::value(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_set" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      (arg1)->set(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_clear" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_setonly__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_setonly" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      (arg1)->setonly(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_setonly__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Menu_Item *arg2 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_setonly" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu_Item_setonly" "', argument " "2"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg2 = (Fl_Menu_Item *)(argp2);
  {
    try {
      (arg1)->setonly((Fl_Menu_Item const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_setonly(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_setonly", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu_Item_setonly__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu_Item_setonly__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu_Item_setonly'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_Item::setonly()\n"
    "    Fl_Menu_Item::setonly(Fl_Menu_Item const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_visible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_visible" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Menu_Item const *)arg1)->visible(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_show(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_show" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      (arg1)->show(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_hide(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_hide" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      (arg1)->hide(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_active(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_active" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Menu_Item const *)arg1)->active(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_activate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_activate" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      (arg1)->activate(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_deactivate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_deactivate" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      (arg1)->deactivate(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_activevisible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_activevisible" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Menu_Item const *)arg1)->activevisible(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_selectable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_selectable" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Menu_Item const *)arg1)->selectable(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_headline__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_headline" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_headline" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = (bool)(val2);
  {
    try {
      (arg1)->headline(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_headline__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_headline" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Menu_Item const *)arg1)->headline(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_headline(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_headline", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu_Item_headline__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu_Item_headline__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu_Item_headline'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_Item::headline(bool)\n"
    "    Fl_Menu_Item::headline() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_image__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Image *arg2 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_image" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu_Item_image" "', argument " "2"" of type '" "Fl_Image *""'"); 
  }
  arg2 = (Fl_Image *)(argp2);
  {
    try {
      (arg1)->image(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_image__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Image *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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_image" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Image,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu_Item_image" "', argument " "2"" of type '" "Fl_Image &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Menu_Item_image" "', argument " "2"" of type '" "Fl_Image &""'"); 
  }
  arg2 = (Fl_Image *)(argp2);
  {
    try {
      (arg1)->image(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_image(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_image", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Image, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Menu_Item_image__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu_Item_image__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu_Item_image'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_Item::image(Fl_Image *)\n"
    "    Fl_Menu_Item::image(Fl_Image &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_measure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  int *arg2 = (int *) 0 ;
  Fl_Menu_ *arg3 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_measure", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_measure" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(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 '" "Fl_Menu_Item_measure" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (int *)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Menu_Item_measure" "', argument " "3"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg3 = (Fl_Menu_ *)(argp3);
  {
    try {
      result = (int)((Fl_Menu_Item const *)arg1)->measure(arg2,(Fl_Menu_ const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  Fl_Menu_ *arg6 = (Fl_Menu_ *) 0 ;
  int arg7 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_draw", 6, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_draw" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu_Item_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Menu_Item_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Menu_Item_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Fl_Menu_Item_draw" "', argument " "6"" of type '" "Fl_Menu_ const *""'"); 
  }
  arg6 = (Fl_Menu_ *)(argp6);
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Menu_Item_draw" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  {
    try {
      ((Fl_Menu_Item const *)arg1)->draw(arg2,arg3,arg4,arg5,(Fl_Menu_ const *)arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_popup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  int arg2 ;
  int arg3 ;
  char *arg4 = (char *) 0 ;
  Fl_Menu_Item *arg5 = (Fl_Menu_Item *) 0 ;
  Fl_Menu_ *arg6 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_popup", 3, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_popup" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_popup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu_Item_popup" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  if (swig_obj[3]) {
    res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Menu_Item_popup" "', argument " "4"" of type '" "char const *""'");
    }
    arg4 = (char *)(buf4);
  }
  if (swig_obj[4]) {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Fl_Menu_Item_popup" "', argument " "5"" of type '" "Fl_Menu_Item const *""'"); 
    }
    arg5 = (Fl_Menu_Item *)(argp5);
  }
  if (swig_obj[5]) {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Fl_Menu_Item_popup" "', argument " "6"" of type '" "Fl_Menu_ const *""'"); 
    }
    arg6 = (Fl_Menu_ *)(argp6);
  }
  {
    try {
      result = (Fl_Menu_Item *)((Fl_Menu_Item const *)arg1)->popup(arg2,arg3,(char const *)arg4,(Fl_Menu_Item const *)arg5,(Fl_Menu_ const *)arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_pulldown(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  Fl_Menu_Item *arg6 = (Fl_Menu_Item *) 0 ;
  Fl_Menu_ *arg7 = (Fl_Menu_ *) 0 ;
  Fl_Menu_Item *arg8 = (Fl_Menu_Item *) 0 ;
  int arg9 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyObject *swig_obj[9] ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_pulldown", 5, 9, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_pulldown" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_pulldown" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu_Item_pulldown" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Menu_Item_pulldown" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Menu_Item_pulldown" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Fl_Menu_Item_pulldown" "', argument " "6"" of type '" "Fl_Menu_Item const *""'"); 
    }
    arg6 = (Fl_Menu_Item *)(argp6);
  }
  if (swig_obj[6]) {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_Fl_Menu_, 0 |  0 );
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Fl_Menu_Item_pulldown" "', argument " "7"" of type '" "Fl_Menu_ const *""'"); 
    }
    arg7 = (Fl_Menu_ *)(argp7);
  }
  if (swig_obj[7]) {
    res8 = SWIG_ConvertPtr(swig_obj[7], &argp8,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Fl_Menu_Item_pulldown" "', argument " "8"" of type '" "Fl_Menu_Item const *""'"); 
    }
    arg8 = (Fl_Menu_Item *)(argp8);
  }
  if (swig_obj[8]) {
    ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Fl_Menu_Item_pulldown" "', argument " "9"" of type '" "int""'");
    } 
    arg9 = (int)(val9);
  }
  {
    try {
      result = (Fl_Menu_Item *)((Fl_Menu_Item const *)arg1)->pulldown(arg2,arg3,arg4,arg5,(Fl_Menu_Item const *)arg6,(Fl_Menu_ const *)arg7,(Fl_Menu_Item const *)arg8,arg9); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_test_shortcut(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_test_shortcut" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (Fl_Menu_Item *)((Fl_Menu_Item const *)arg1)->test_shortcut(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_find_shortcut(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  int *arg2 = (int *) 0 ;
  bool arg3 = (bool) (bool)false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_find_shortcut", 1, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_find_shortcut" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu_Item_find_shortcut" "', argument " "2"" of type '" "int *""'"); 
    }
    arg2 = (int *)(argp2);
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu_Item_find_shortcut" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = (bool)(val3);
  }
  {
    try {
      result = (Fl_Menu_Item *)((Fl_Menu_Item const *)arg1)->find_shortcut(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_do_callback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  Fl_Callback_Reason arg3 = (Fl_Callback_Reason) FL_REASON_UNKNOWN ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_do_callback" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu_Item_do_callback" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu_Item_do_callback" "', argument " "3"" of type '" "Fl_Callback_Reason""'");
    } 
    arg3 = (Fl_Callback_Reason)(val3);
  }
  {
    try {
      ((Fl_Menu_Item const *)arg1)->do_callback(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_do_callback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *arg3 = (void *) 0 ;
  Fl_Callback_Reason arg4 = (Fl_Callback_Reason) FL_REASON_UNKNOWN ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_do_callback" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu_Item_do_callback" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Menu_Item_do_callback" "', argument " "3"" of type '" "void *""'"); 
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Menu_Item_do_callback" "', argument " "4"" of type '" "Fl_Callback_Reason""'");
    } 
    arg4 = (Fl_Callback_Reason)(val4);
  }
  {
    try {
      ((Fl_Menu_Item const *)arg1)->do_callback(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_do_callback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  long arg3 ;
  Fl_Callback_Reason arg4 = (Fl_Callback_Reason) FL_REASON_UNKNOWN ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_do_callback" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu_Item_do_callback" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu_Item_do_callback" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = (long)(val3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Menu_Item_do_callback" "', argument " "4"" of type '" "Fl_Callback_Reason""'");
    } 
    arg4 = (Fl_Callback_Reason)(val4);
  }
  {
    try {
      ((Fl_Menu_Item const *)arg1)->do_callback(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_do_callback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_do_callback", 0, 4, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    if (argc > 2) {
      {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (!_v) goto check_1;
    }
    return _wrap_Fl_Menu_Item_do_callback__SWIG_0(self, argc, argv);
  }
check_1:
  
  if ((argc >= 3) && (argc <= 4)) {
    int _v = 0;
    {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    PyObject *retobj = _wrap_Fl_Menu_Item_do_callback__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_2:
  
  if ((argc >= 3) && (argc <= 4)) {
    PyObject *retobj = _wrap_Fl_Menu_Item_do_callback__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu_Item_do_callback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_Item::do_callback(Fl_Widget *,Fl_Callback_Reason) const\n"
    "    Fl_Menu_Item::do_callback(Fl_Widget *,void *,Fl_Callback_Reason) const\n"
    "    Fl_Menu_Item::do_callback(Fl_Widget *,long,Fl_Callback_Reason) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  Fl_Callback *arg5 = (Fl_Callback *) 0 ;
  void *arg6 = (void *) 0 ;
  int arg7 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int res6 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_insert", 5, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_insert" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_insert" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Menu_Item_insert" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Menu_Item_insert" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[4], (void**)(&arg5), SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Menu_Item_insert" "', argument " "5"" of type '" "Fl_Callback *""'"); 
    }
  }
  if (swig_obj[5]) {
    res6 = SWIG_ConvertPtr(swig_obj[5],SWIG_as_voidptrptr(&arg6), 0, 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Fl_Menu_Item_insert" "', argument " "6"" of type '" "void *""'"); 
    }
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Menu_Item_insert" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  {
    try {
      result = (int)(arg1)->insert(arg2,(char const *)arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_add__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  Fl_Callback *arg4 = (Fl_Callback *) 0 ;
  void *arg5 = (void *) 0 ;
  int arg6 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res5 ;
  int val6 ;
  int ecode6 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_add" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu_Item_add" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu_Item_add" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[3], (void**)(&arg4), SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Menu_Item_add" "', argument " "4"" of type '" "Fl_Callback *""'"); 
    }
  }
  if (swig_obj[4]) {
    res5 = SWIG_ConvertPtr(swig_obj[4],SWIG_as_voidptrptr(&arg5), 0, 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Fl_Menu_Item_add" "', argument " "5"" of type '" "void *""'"); 
    }
  }
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Menu_Item_add" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  {
    try {
      result = (int)(arg1)->add((char const *)arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_add__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  Fl_Callback *arg4 = (Fl_Callback *) 0 ;
  void *arg5 = (void *) 0 ;
  int arg6 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res5 ;
  int val6 ;
  int ecode6 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_add" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu_Item_add" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Menu_Item_add" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[3], (void**)(&arg4), SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Menu_Item_add" "', argument " "4"" of type '" "Fl_Callback *""'"); 
    }
  }
  if (swig_obj[4]) {
    res5 = SWIG_ConvertPtr(swig_obj[4],SWIG_as_voidptrptr(&arg5), 0, 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Fl_Menu_Item_add" "', argument " "5"" of type '" "void *""'"); 
    }
  }
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Menu_Item_add" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  {
    try {
      result = (int)(arg1)->add((char const *)arg2,(char const *)arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_add", 0, 6, argv))) SWIG_fail;
  --argc;
  if ((argc >= 4) && (argc <= 6)) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_Fl_Menu_Item_add__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if ((argc >= 4) && (argc <= 6)) {
    PyObject *retobj = _wrap_Fl_Menu_Item_add__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu_Item_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_Item::add(char const *,int,Fl_Callback *,void *,int)\n"
    "    Fl_Menu_Item::add(char const *,char const *,Fl_Callback *,void *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_size" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Menu_Item const *)arg1)->size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_callback__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_callback" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (PyObject *)Fl_Menu_Item_callback__SWIG_4(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_callback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_callback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Menu_Item_callback__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_Fl_Widget__void);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_Fl_Menu_Item_callback__SWIG_2(self, argc, argv);
  }
check_2:
  
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_Fl_Widget_long__void);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    if (argc > 2) {
      {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (!_v) goto check_3;
    }
    return _wrap_Fl_Menu_Item_callback__SWIG_3(self, argc, argv);
  }
check_3:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Menu_Item_callback__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Menu_Item_callback__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Menu_Item_callback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_Item::callback(Fl_Callback *,void *)\n"
    "    Fl_Menu_Item::callback(Fl_Callback *)\n"
    "    Fl_Menu_Item::callback(Fl_Callback0 *)\n"
    "    Fl_Menu_Item::callback(Fl_Callback1 *,long)\n"
    "    Fl_Menu_Item::callback()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_user_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 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_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_user_data" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      result = (PyObject *)Fl_Menu_Item_user_data(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_add_multi_label(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Pixmap *arg2 = (Fl_Pixmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Menu_Item_add_multi_label", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_add_multi_label" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Pixmap, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu_Item_add_multi_label" "', argument " "2"" of type '" "Fl_Pixmap *""'"); 
  }
  arg2 = (Fl_Pixmap *)(argp2);
  {
    try {
      Fl_Menu_Item_add_multi_label(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Menu_Item(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Menu_Item", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Menu_Item *)new Fl_Menu_Item(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Menu_Item(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Item, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Menu_Item" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = (Fl_Menu_Item *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Single_Window__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  char *arg4 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  Fl_Single_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Single_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Single_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  if (swig_obj[3]) {
    res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Fl_Single_Window" "', argument " "4"" of type '" "char const *""'");
    }
    arg4 = (char *)(buf4);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Single_Window *)new SwigDirector_Fl_Single_Window(arg1,arg2,arg3,(char const *)arg4); 
      } else {
        result = (Fl_Single_Window *)new Fl_Single_Window(arg2,arg3,(char const *)arg4); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Single_Window, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Single_Window__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  Fl_Single_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Single_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Single_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Single_Window" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Single_Window" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Single_Window" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Single_Window *)new SwigDirector_Fl_Single_Window(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Single_Window *)new Fl_Single_Window(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Single_Window, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Single_Window(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_Single_Window", 0, 6, argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    PyObject *retobj = _wrap_new_Fl_Single_Window__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 5) && (argc <= 6)) {
    PyObject *retobj = _wrap_new_Fl_Single_Window__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_Single_Window'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Single_Window::Fl_Single_Window(int,int,char const *)\n"
    "    Fl_Single_Window::Fl_Single_Window(PyObject *,int,int,int,int,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Single_Window_flush(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Single_Window *arg1 = (Fl_Single_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Single_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Single_Window_flush" "', argument " "1"" of type '" "Fl_Single_Window *""'"); 
  }
  arg1 = (Fl_Single_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Single_Window::flush();
        } else {
          (arg1)->flush();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Single_Window_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Single_Window *arg1 = (Fl_Single_Window *) 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, "Fl_Single_Window_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Single_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Single_Window_init_type" "', argument " "1"" of type '" "Fl_Single_Window *""'"); 
  }
  arg1 = (Fl_Single_Window *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Single_Window_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Single_Window_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Single_Window_show(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Single_Window *arg1 = (Fl_Single_Window *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Single_Window_show", 1, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Single_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Single_Window_show" "', argument " "1"" of type '" "Fl_Single_Window *""'"); 
  }
  arg1 = (Fl_Single_Window *)(argp1);
  if (swig_obj[1]) {
    arg2 = swig_obj[1];
  }
  if (swig_obj[2]) {
    arg3 = swig_obj[2];
  }
  {
    try {
      Fl_Single_Window_show(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Single_Window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Single_Window *arg1 = (Fl_Single_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Single_Window, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Single_Window" "', argument " "1"" of type '" "Fl_Single_Window *""'"); 
  }
  arg1 = (Fl_Single_Window *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Single_Window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Single_Window *arg1 = (Fl_Single_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Single_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Single_Window" "', argument " "1"" of type '" "Fl_Single_Window *""'"); 
  }
  arg1 = (Fl_Single_Window *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Single_Window_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Single_Window *arg1 = (Fl_Single_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Single_Window *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Single_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Single_Window_draw" "', argument " "1"" of type '" "Fl_Single_Window *""'"); 
  }
  arg1 = (Fl_Single_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Single_Window *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_delete_Fl_Menu_Window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Window *arg1 = (Fl_Menu_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Window, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Menu_Window" "', argument " "1"" of type '" "Fl_Menu_Window *""'"); 
  }
  arg1 = (Fl_Menu_Window *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Menu_Window__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  char *arg4 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  Fl_Menu_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Menu_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Menu_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  if (swig_obj[3]) {
    res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Fl_Menu_Window" "', argument " "4"" of type '" "char const *""'");
    }
    arg4 = (char *)(buf4);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Menu_Window *)new SwigDirector_Fl_Menu_Window(arg1,arg2,arg3,(char const *)arg4); 
      } else {
        result = (Fl_Menu_Window *)new Fl_Menu_Window(arg2,arg3,(char const *)arg4); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Window, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Menu_Window__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  Fl_Menu_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Menu_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Menu_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Menu_Window" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Menu_Window" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Menu_Window" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Menu_Window *)new SwigDirector_Fl_Menu_Window(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Menu_Window *)new Fl_Menu_Window(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Window, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Menu_Window(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_Menu_Window", 0, 6, argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    PyObject *retobj = _wrap_new_Fl_Menu_Window__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 5) && (argc <= 6)) {
    PyObject *retobj = _wrap_new_Fl_Menu_Window__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_Menu_Window'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_Window::Fl_Menu_Window(int,int,char const *)\n"
    "    Fl_Menu_Window::Fl_Menu_Window(PyObject *,int,int,int,int,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Window_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Window *arg1 = (Fl_Menu_Window *) 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, "Fl_Menu_Window_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Window_init_type" "', argument " "1"" of type '" "Fl_Menu_Window *""'"); 
  }
  arg1 = (Fl_Menu_Window *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu_Window_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Menu_Window_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Menu_Window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Window *arg1 = (Fl_Menu_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Menu_Window" "', argument " "1"" of type '" "Fl_Menu_Window *""'"); 
  }
  arg1 = (Fl_Menu_Window *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Window_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Window *arg1 = (Fl_Menu_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Menu_Window *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Menu_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Window_draw" "', argument " "1"" of type '" "Fl_Menu_Window *""'"); 
  }
  arg1 = (Fl_Menu_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Menu_Window *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Multiline_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Multiline_Input *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Multiline_Input", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Multiline_Input" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Multiline_Input" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Multiline_Input" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Multiline_Input" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Multiline_Input" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Multiline_Input *)new SwigDirector_Fl_Multiline_Input(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Multiline_Input *)new Fl_Multiline_Input(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Multiline_Input, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multiline_Input_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multiline_Input *arg1 = (Fl_Multiline_Input *) 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, "Fl_Multiline_Input_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multiline_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multiline_Input_init_type" "', argument " "1"" of type '" "Fl_Multiline_Input *""'"); 
  }
  arg1 = (Fl_Multiline_Input *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Multiline_Input_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Multiline_Input_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Multiline_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multiline_Input *arg1 = (Fl_Multiline_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multiline_Input, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Multiline_Input" "', argument " "1"" of type '" "Fl_Multiline_Input *""'"); 
  }
  arg1 = (Fl_Multiline_Input *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Multiline_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multiline_Input *arg1 = (Fl_Multiline_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multiline_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Multiline_Input" "', argument " "1"" of type '" "Fl_Multiline_Input *""'"); 
  }
  arg1 = (Fl_Multiline_Input *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multiline_Input_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multiline_Input *arg1 = (Fl_Multiline_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multiline_Input *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multiline_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multiline_Input_draw" "', argument " "1"" of type '" "Fl_Multiline_Input *""'"); 
  }
  arg1 = (Fl_Multiline_Input *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multiline_Input *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Output *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Output", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Output" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Output" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Output" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Output" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Output" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Output *)new SwigDirector_Fl_Output(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Output *)new Fl_Output(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Output, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Output_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Output *arg1 = (Fl_Output *) 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, "Fl_Output_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Output_init_type" "', argument " "1"" of type '" "Fl_Output *""'"); 
  }
  arg1 = (Fl_Output *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Output_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Output_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Output *arg1 = (Fl_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Output, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Output" "', argument " "1"" of type '" "Fl_Output *""'"); 
  }
  arg1 = (Fl_Output *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Output *arg1 = (Fl_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Output" "', argument " "1"" of type '" "Fl_Output *""'"); 
  }
  arg1 = (Fl_Output *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Output_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Output *arg1 = (Fl_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Output *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Output_draw" "', argument " "1"" of type '" "Fl_Output *""'"); 
  }
  arg1 = (Fl_Output *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Output *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Multiline_Output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Multiline_Output *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Multiline_Output", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Multiline_Output" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Multiline_Output" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Multiline_Output" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Multiline_Output" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Multiline_Output" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Multiline_Output *)new SwigDirector_Fl_Multiline_Output(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Multiline_Output *)new Fl_Multiline_Output(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Multiline_Output, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multiline_Output_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multiline_Output *arg1 = (Fl_Multiline_Output *) 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, "Fl_Multiline_Output_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multiline_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multiline_Output_init_type" "', argument " "1"" of type '" "Fl_Multiline_Output *""'"); 
  }
  arg1 = (Fl_Multiline_Output *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Multiline_Output_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Multiline_Output_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Multiline_Output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multiline_Output *arg1 = (Fl_Multiline_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multiline_Output, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Multiline_Output" "', argument " "1"" of type '" "Fl_Multiline_Output *""'"); 
  }
  arg1 = (Fl_Multiline_Output *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Multiline_Output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multiline_Output *arg1 = (Fl_Multiline_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multiline_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Multiline_Output" "', argument " "1"" of type '" "Fl_Multiline_Output *""'"); 
  }
  arg1 = (Fl_Multiline_Output *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multiline_Output_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multiline_Output *arg1 = (Fl_Multiline_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multiline_Output *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multiline_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multiline_Output_draw" "', argument " "1"" of type '" "Fl_Multiline_Output *""'"); 
  }
  arg1 = (Fl_Multiline_Output *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multiline_Output *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Multi_Browser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Multi_Browser *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Multi_Browser", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Multi_Browser" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Multi_Browser" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Multi_Browser" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Multi_Browser" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Multi_Browser" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Multi_Browser *)new SwigDirector_Fl_Multi_Browser(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Multi_Browser *)new Fl_Multi_Browser(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Multi_Browser, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 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, "Fl_Multi_Browser_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Browser_init_type" "', argument " "1"" of type '" "Fl_Multi_Browser *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Multi_Browser_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Multi_Browser_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Multi_Browser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Multi_Browser" "', argument " "1"" of type '" "Fl_Multi_Browser *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Multi_Browser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Multi_Browser" "', argument " "1"" of type '" "Fl_Multi_Browser *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Browser_draw" "', argument " "1"" of type '" "Fl_Multi_Browser *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_first(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Browser_item_first" "', argument " "1"" of type '" "Fl_Multi_Browser const *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_first"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_first");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Multi_Browser const *)darg)->item_firstSwigPublic();
        } else {
          result = (void *)((SwigDirector_Fl_Multi_Browser const *)darg)->item_first();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Multi_Browser_item_next", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Browser_item_next" "', argument " "1"" of type '" "Fl_Multi_Browser const *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(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 '" "Fl_Multi_Browser_item_next" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_next"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_next");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Multi_Browser const *)darg)->item_nextSwigPublic(arg2);
        } else {
          result = (void *)((SwigDirector_Fl_Multi_Browser const *)darg)->item_next(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_prev(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Multi_Browser_item_prev", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Browser_item_prev" "', argument " "1"" of type '" "Fl_Multi_Browser const *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(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 '" "Fl_Multi_Browser_item_prev" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_prev"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_prev");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Multi_Browser const *)darg)->item_prevSwigPublic(arg2);
        } else {
          result = (void *)((SwigDirector_Fl_Multi_Browser const *)darg)->item_prev(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_last(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Browser_item_last" "', argument " "1"" of type '" "Fl_Multi_Browser const *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_last"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_last");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Multi_Browser const *)darg)->item_lastSwigPublic();
        } else {
          result = (void *)((SwigDirector_Fl_Multi_Browser const *)darg)->item_last();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Multi_Browser_item_height", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Browser_item_height" "', argument " "1"" of type '" "Fl_Multi_Browser const *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(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 '" "Fl_Multi_Browser_item_height" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Multi_Browser const *)darg)->item_heightSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Multi_Browser const *)darg)->item_height(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_width(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Multi_Browser_item_width", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Browser_item_width" "', argument " "1"" of type '" "Fl_Multi_Browser const *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(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 '" "Fl_Multi_Browser_item_width" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_width"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_width");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Multi_Browser const *)darg)->item_widthSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Multi_Browser const *)darg)->item_width(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_quick_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Multi_Browser_item_quick_height", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Browser_item_quick_height" "', argument " "1"" of type '" "Fl_Multi_Browser const *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(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 '" "Fl_Multi_Browser_item_quick_height" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_quick_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_quick_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Multi_Browser const *)darg)->item_quick_heightSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Multi_Browser const *)darg)->item_quick_height(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Multi_Browser_item_draw", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Browser_item_draw" "', argument " "1"" of type '" "Fl_Multi_Browser const *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(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 '" "Fl_Multi_Browser_item_draw" "', 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 '" "Fl_Multi_Browser_item_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Multi_Browser_item_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Multi_Browser_item_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Multi_Browser_item_draw" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    {
      try {
        if (upcall) {
          ((SwigDirector_Fl_Multi_Browser const *)darg)->item_drawSwigPublic(arg2,arg3,arg4,arg5,arg6);
        } else {
          ((SwigDirector_Fl_Multi_Browser const *)darg)->item_draw(arg2,arg3,arg4,arg5,arg6);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_text(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Multi_Browser_item_text", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Browser_item_text" "', argument " "1"" of type '" "Fl_Multi_Browser const *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(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 '" "Fl_Multi_Browser_item_text" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_text"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_text");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (char *)((SwigDirector_Fl_Multi_Browser const *)darg)->item_textSwigPublic(arg2);
        } else {
          result = (char *)((SwigDirector_Fl_Multi_Browser const *)darg)->item_text(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (director) {
    director->swig_release_ownership(SWIG_as_voidptr(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Multi_Browser_item_swap", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Browser_item_swap" "', argument " "1"" of type '" "Fl_Multi_Browser *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(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 '" "Fl_Multi_Browser_item_swap" "', argument " "2"" of type '" "void *""'"); 
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Multi_Browser_item_swap" "', argument " "3"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_swap"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_swap");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->item_swapSwigPublic(arg2,arg3);
        } else {
          (darg)->item_swap(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_at(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Multi_Browser_item_at", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Browser_item_at" "', argument " "1"" of type '" "Fl_Multi_Browser const *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Multi_Browser_item_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_at"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_at");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Multi_Browser const *)darg)->item_atSwigPublic(arg2);
        } else {
          result = (void *)((SwigDirector_Fl_Multi_Browser const *)darg)->item_at(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_full_width(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Browser_full_width" "', argument " "1"" of type '" "Fl_Multi_Browser const *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("full_width"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member full_width");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Multi_Browser const *)darg)->full_widthSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Multi_Browser const *)darg)->full_width();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_full_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Browser_full_height" "', argument " "1"" of type '" "Fl_Multi_Browser const *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("full_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member full_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Multi_Browser const *)darg)->full_heightSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Multi_Browser const *)darg)->full_height();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_incr_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Browser_incr_height" "', argument " "1"" of type '" "Fl_Multi_Browser const *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("incr_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member incr_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Multi_Browser const *)darg)->incr_heightSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Multi_Browser const *)darg)->incr_height();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_select(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Multi_Browser_item_select", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Browser_item_select" "', argument " "1"" of type '" "Fl_Multi_Browser *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(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 '" "Fl_Multi_Browser_item_select" "', 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 '" "Fl_Multi_Browser_item_select" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_select"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_select");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->item_selectSwigPublic(arg2,arg3);
        } else {
          (darg)->item_select(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_selected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Multi_Browser_item_selected", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Browser_item_selected" "', argument " "1"" of type '" "Fl_Multi_Browser const *""'"); 
  }
  arg1 = (Fl_Multi_Browser *)(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 '" "Fl_Multi_Browser_item_selected" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_selected"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_selected");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Multi_Browser const *)darg)->item_selectedSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Multi_Browser const *)darg)->item_selected(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Multi_Label_label__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Multi_Label *arg1 = (Fl_Multi_Label *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Label, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Label_label" "', argument " "1"" of type '" "Fl_Multi_Label *""'"); 
  }
  arg1 = (Fl_Multi_Label *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Multi_Label_label" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  {
    try {
      (arg1)->label(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Label_label__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Multi_Label *arg1 = (Fl_Multi_Label *) 0 ;
  Fl_Menu_Item *arg2 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Label, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Multi_Label_label" "', argument " "1"" of type '" "Fl_Multi_Label *""'"); 
  }
  arg1 = (Fl_Multi_Label *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Multi_Label_label" "', argument " "2"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg2 = (Fl_Menu_Item *)(argp2);
  {
    try {
      (arg1)->label(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Label_label(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Multi_Label_label", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Widget, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Multi_Label_label__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Multi_Label_label__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Multi_Label_label'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Multi_Label::label(Fl_Widget *)\n"
    "    Fl_Multi_Label::label(Fl_Menu_Item *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Fl_Multi_Label(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Label *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Multi_Label", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Multi_Label *)new Fl_Multi_Label(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Multi_Label, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Multi_Label(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Label *arg1 = (Fl_Multi_Label *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Multi_Label, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Multi_Label" "', argument " "1"" of type '" "Fl_Multi_Label *""'"); 
  }
  arg1 = (Fl_Multi_Label *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Nice_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Nice_Slider *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Nice_Slider", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Nice_Slider" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Nice_Slider" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Nice_Slider" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Nice_Slider" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Nice_Slider" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Nice_Slider *)new SwigDirector_Fl_Nice_Slider(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Nice_Slider *)new Fl_Nice_Slider(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Nice_Slider, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Nice_Slider_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Nice_Slider *arg1 = (Fl_Nice_Slider *) 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, "Fl_Nice_Slider_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Nice_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Nice_Slider_init_type" "', argument " "1"" of type '" "Fl_Nice_Slider *""'"); 
  }
  arg1 = (Fl_Nice_Slider *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Nice_Slider_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Nice_Slider_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Nice_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Nice_Slider *arg1 = (Fl_Nice_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Nice_Slider, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Nice_Slider" "', argument " "1"" of type '" "Fl_Nice_Slider *""'"); 
  }
  arg1 = (Fl_Nice_Slider *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Nice_Slider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Nice_Slider *arg1 = (Fl_Nice_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Nice_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Nice_Slider" "', argument " "1"" of type '" "Fl_Nice_Slider *""'"); 
  }
  arg1 = (Fl_Nice_Slider *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Nice_Slider_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Nice_Slider *arg1 = (Fl_Nice_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Nice_Slider *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Nice_Slider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Nice_Slider_draw" "', argument " "1"" of type '" "Fl_Nice_Slider *""'"); 
  }
  arg1 = (Fl_Nice_Slider *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Nice_Slider *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Native_File_Chooser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 = (int) Fl_Native_File_Chooser::BROWSE_FILE ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Native_File_Chooser *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Native_File_Chooser", 0, 1, swig_obj)) SWIG_fail;
  if (swig_obj[0]) {
    ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Fl_Native_File_Chooser" "', argument " "1"" of type '" "int""'");
    } 
    arg1 = (int)(val1);
  }
  {
    try {
      result = (Fl_Native_File_Chooser *)new Fl_Native_File_Chooser(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Native_File_Chooser, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Native_File_Chooser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Native_File_Chooser" "', argument " "1"" of type '" "Fl_Native_File_Chooser *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_type__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 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_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_type" "', argument " "1"" of type '" "Fl_Native_File_Chooser *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Native_File_Chooser_type" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->type(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_type__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 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_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_type" "', argument " "1"" of type '" "Fl_Native_File_Chooser const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  {
    try {
      result = (int)((Fl_Native_File_Chooser const *)arg1)->type(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_type(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Native_File_Chooser_type", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_type__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_type__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Native_File_Chooser_type'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Native_File_Chooser::type(int)\n"
    "    Fl_Native_File_Chooser::type() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_options__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 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_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_options" "', argument " "1"" of type '" "Fl_Native_File_Chooser *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Native_File_Chooser_options" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->options(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_options__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 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_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_options" "', argument " "1"" of type '" "Fl_Native_File_Chooser const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  {
    try {
      result = (int)((Fl_Native_File_Chooser const *)arg1)->options(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_options(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Native_File_Chooser_options", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_options__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_options__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Native_File_Chooser_options'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Native_File_Chooser::options(int)\n"
    "    Fl_Native_File_Chooser::options() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 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_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_count" "', argument " "1"" of type '" "Fl_Native_File_Chooser const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  {
    try {
      result = (int)((Fl_Native_File_Chooser const *)arg1)->count(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_filename__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_filename" "', argument " "1"" of type '" "Fl_Native_File_Chooser const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  {
    try {
      result = (char *)((Fl_Native_File_Chooser const *)arg1)->filename(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_filename__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_filename" "', argument " "1"" of type '" "Fl_Native_File_Chooser const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Native_File_Chooser_filename" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (char *)((Fl_Native_File_Chooser const *)arg1)->filename(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_filename(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Native_File_Chooser_filename", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_filename__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_filename__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Native_File_Chooser_filename'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Native_File_Chooser::filename() const\n"
    "    Fl_Native_File_Chooser::filename(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_directory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_directory" "', argument " "1"" of type '" "Fl_Native_File_Chooser *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Native_File_Chooser_directory" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->directory((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_directory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_directory" "', argument " "1"" of type '" "Fl_Native_File_Chooser const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  {
    try {
      result = (char *)((Fl_Native_File_Chooser const *)arg1)->directory(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_directory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Native_File_Chooser_directory", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_directory__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_directory__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Native_File_Chooser_directory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Native_File_Chooser::directory(char const *)\n"
    "    Fl_Native_File_Chooser::directory() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_title__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_title" "', argument " "1"" of type '" "Fl_Native_File_Chooser *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Native_File_Chooser_title" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->title((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_title__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_title" "', argument " "1"" of type '" "Fl_Native_File_Chooser const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  {
    try {
      result = (char *)((Fl_Native_File_Chooser const *)arg1)->title(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_title(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Native_File_Chooser_title", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_title__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_title__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Native_File_Chooser_title'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Native_File_Chooser::title(char const *)\n"
    "    Fl_Native_File_Chooser::title() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_filter__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_filter" "', argument " "1"" of type '" "Fl_Native_File_Chooser const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  {
    try {
      result = (char *)((Fl_Native_File_Chooser const *)arg1)->filter(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_filter__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_filter" "', argument " "1"" of type '" "Fl_Native_File_Chooser *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Native_File_Chooser_filter" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->filter((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_filter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Native_File_Chooser_filter", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_filter__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_filter__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Native_File_Chooser_filter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Native_File_Chooser::filter() const\n"
    "    Fl_Native_File_Chooser::filter(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_filters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 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_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_filters" "', argument " "1"" of type '" "Fl_Native_File_Chooser const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  {
    try {
      result = (int)((Fl_Native_File_Chooser const *)arg1)->filters(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_filter_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 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_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_filter_value" "', argument " "1"" of type '" "Fl_Native_File_Chooser *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Native_File_Chooser_filter_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->filter_value(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_filter_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 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_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_filter_value" "', argument " "1"" of type '" "Fl_Native_File_Chooser const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  {
    try {
      result = (int)((Fl_Native_File_Chooser const *)arg1)->filter_value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_filter_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Native_File_Chooser_filter_value", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_filter_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_filter_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Native_File_Chooser_filter_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Native_File_Chooser::filter_value(int)\n"
    "    Fl_Native_File_Chooser::filter_value() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_preset_file__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_preset_file" "', argument " "1"" of type '" "Fl_Native_File_Chooser *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Native_File_Chooser_preset_file" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->preset_file((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_preset_file__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_preset_file" "', argument " "1"" of type '" "Fl_Native_File_Chooser const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  {
    try {
      result = (char *)((Fl_Native_File_Chooser const *)arg1)->preset_file(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_preset_file(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Native_File_Chooser_preset_file", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_preset_file__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_preset_file__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Native_File_Chooser_preset_file'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Native_File_Chooser::preset_file(char const *)\n"
    "    Fl_Native_File_Chooser::preset_file() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_errmsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 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_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_errmsg" "', argument " "1"" of type '" "Fl_Native_File_Chooser const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  {
    try {
      result = (char *)((Fl_Native_File_Chooser const *)arg1)->errmsg(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_show(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser *arg1 = (Fl_Native_File_Chooser *) 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_Fl_Native_File_Chooser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_show" "', argument " "1"" of type '" "Fl_Native_File_Chooser *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser *)(argp1);
  {
    try {
      result = (int)(arg1)->show(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Native_File_Chooser_Driver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Fl_Native_File_Chooser_Driver *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Native_File_Chooser_Driver", 2, 2, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Native_File_Chooser_Driver" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Native_File_Chooser_Driver *)new SwigDirector_Fl_Native_File_Chooser_Driver(arg1,arg2); 
      } else {
        result = (Fl_Native_File_Chooser_Driver *)new Fl_Native_File_Chooser_Driver(arg2); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Native_File_Chooser_Driver, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Native_File_Chooser_Driver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Native_File_Chooser_Driver" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_type__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_type" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Native_File_Chooser_Driver_type" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Native_File_Chooser_Driver::type(arg2);
        } else {
          (arg1)->type(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_type__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_type" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)((Fl_Native_File_Chooser_Driver const *)arg1)->Fl_Native_File_Chooser_Driver::type();
        } else {
          result = (int)((Fl_Native_File_Chooser_Driver const *)arg1)->type();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_type(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Native_File_Chooser_Driver_type", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_Driver_type__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_Driver_type__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Native_File_Chooser_Driver_type'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Native_File_Chooser_Driver::type(int)\n"
    "    Fl_Native_File_Chooser_Driver::type() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_options__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_options" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Native_File_Chooser_Driver_options" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Native_File_Chooser_Driver::options(arg2);
        } else {
          (arg1)->options(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_options__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_options" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)((Fl_Native_File_Chooser_Driver const *)arg1)->Fl_Native_File_Chooser_Driver::options();
        } else {
          result = (int)((Fl_Native_File_Chooser_Driver const *)arg1)->options();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_options(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Native_File_Chooser_Driver_options", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_Driver_options__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_Driver_options__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Native_File_Chooser_Driver_options'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Native_File_Chooser_Driver::options(int)\n"
    "    Fl_Native_File_Chooser_Driver::options() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_count" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)((Fl_Native_File_Chooser_Driver const *)arg1)->Fl_Native_File_Chooser_Driver::count();
        } else {
          result = (int)((Fl_Native_File_Chooser_Driver const *)arg1)->count();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_filename__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_filename" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (char *)((Fl_Native_File_Chooser_Driver const *)arg1)->Fl_Native_File_Chooser_Driver::filename();
        } else {
          result = (char *)((Fl_Native_File_Chooser_Driver const *)arg1)->filename();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (director) {
    director->swig_release_ownership(SWIG_as_voidptr(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_filename__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_filename" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Native_File_Chooser_Driver_filename" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (char *)((Fl_Native_File_Chooser_Driver const *)arg1)->Fl_Native_File_Chooser_Driver::filename(arg2);
        } else {
          result = (char *)((Fl_Native_File_Chooser_Driver const *)arg1)->filename(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (director) {
    director->swig_release_ownership(SWIG_as_voidptr(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_filename(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Native_File_Chooser_Driver_filename", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_Driver_filename__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_Driver_filename__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Native_File_Chooser_Driver_filename'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Native_File_Chooser_Driver::filename() const\n"
    "    Fl_Native_File_Chooser_Driver::filename(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_directory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_directory" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Native_File_Chooser_Driver_directory" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Native_File_Chooser_Driver::directory((char const *)arg2);
        } else {
          (arg1)->directory((char const *)arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_directory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_directory" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (char *)((Fl_Native_File_Chooser_Driver const *)arg1)->Fl_Native_File_Chooser_Driver::directory();
        } else {
          result = (char *)((Fl_Native_File_Chooser_Driver const *)arg1)->directory();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (director) {
    director->swig_release_ownership(SWIG_as_voidptr(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_directory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Native_File_Chooser_Driver_directory", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_Driver_directory__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_Driver_directory__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Native_File_Chooser_Driver_directory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Native_File_Chooser_Driver::directory(char const *)\n"
    "    Fl_Native_File_Chooser_Driver::directory() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_title__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_title" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Native_File_Chooser_Driver_title" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Native_File_Chooser_Driver::title((char const *)arg2);
        } else {
          (arg1)->title((char const *)arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_title__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_title" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (char *)((Fl_Native_File_Chooser_Driver const *)arg1)->Fl_Native_File_Chooser_Driver::title();
        } else {
          result = (char *)((Fl_Native_File_Chooser_Driver const *)arg1)->title();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (director) {
    director->swig_release_ownership(SWIG_as_voidptr(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_title(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Native_File_Chooser_Driver_title", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_Driver_title__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_Driver_title__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Native_File_Chooser_Driver_title'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Native_File_Chooser_Driver::title(char const *)\n"
    "    Fl_Native_File_Chooser_Driver::title() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_filter__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_filter" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (char *)((Fl_Native_File_Chooser_Driver const *)arg1)->Fl_Native_File_Chooser_Driver::filter();
        } else {
          result = (char *)((Fl_Native_File_Chooser_Driver const *)arg1)->filter();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (director) {
    director->swig_release_ownership(SWIG_as_voidptr(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_filter__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_filter" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Native_File_Chooser_Driver_filter" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Native_File_Chooser_Driver::filter((char const *)arg2);
        } else {
          (arg1)->filter((char const *)arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_filter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Native_File_Chooser_Driver_filter", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_Driver_filter__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_Driver_filter__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Native_File_Chooser_Driver_filter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Native_File_Chooser_Driver::filter() const\n"
    "    Fl_Native_File_Chooser_Driver::filter(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_filters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_filters" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)((Fl_Native_File_Chooser_Driver const *)arg1)->Fl_Native_File_Chooser_Driver::filters();
        } else {
          result = (int)((Fl_Native_File_Chooser_Driver const *)arg1)->filters();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_filter_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_filter_value" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Native_File_Chooser_Driver_filter_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Native_File_Chooser_Driver::filter_value(arg2);
        } else {
          (arg1)->filter_value(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_filter_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_filter_value" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)((Fl_Native_File_Chooser_Driver const *)arg1)->Fl_Native_File_Chooser_Driver::filter_value();
        } else {
          result = (int)((Fl_Native_File_Chooser_Driver const *)arg1)->filter_value();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_filter_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Native_File_Chooser_Driver_filter_value", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_Driver_filter_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_Driver_filter_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Native_File_Chooser_Driver_filter_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Native_File_Chooser_Driver::filter_value(int)\n"
    "    Fl_Native_File_Chooser_Driver::filter_value() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_preset_file__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_preset_file" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Native_File_Chooser_Driver_preset_file" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Native_File_Chooser_Driver::preset_file((char const *)arg2);
        } else {
          (arg1)->preset_file((char const *)arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_preset_file__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_preset_file" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (char *)((Fl_Native_File_Chooser_Driver const *)arg1)->Fl_Native_File_Chooser_Driver::preset_file();
        } else {
          result = (char *)((Fl_Native_File_Chooser_Driver const *)arg1)->preset_file();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (director) {
    director->swig_release_ownership(SWIG_as_voidptr(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_preset_file(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Native_File_Chooser_Driver_preset_file", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_Driver_preset_file__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Native_File_Chooser_Driver_preset_file__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Native_File_Chooser_Driver_preset_file'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Native_File_Chooser_Driver::preset_file(char const *)\n"
    "    Fl_Native_File_Chooser_Driver::preset_file() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_errmsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_errmsg" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver const *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (char *)((Fl_Native_File_Chooser_Driver const *)arg1)->Fl_Native_File_Chooser_Driver::errmsg();
        } else {
          result = (char *)((Fl_Native_File_Chooser_Driver const *)arg1)->errmsg();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (director) {
    director->swig_release_ownership(SWIG_as_voidptr(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Native_File_Chooser_Driver_show(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Native_File_Chooser_Driver_show" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Native_File_Chooser_Driver::show();
        } else {
          result = (int)(arg1)->show();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Native_File_Chooser_Driver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Native_File_Chooser_Driver *arg1 = (Fl_Native_File_Chooser_Driver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Native_File_Chooser_Driver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Native_File_Chooser_Driver" "', argument " "1"" of type '" "Fl_Native_File_Chooser_Driver *""'"); 
  }
  arg1 = (Fl_Native_File_Chooser_Driver *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Overlay_Window_draw_overlay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Overlay_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Overlay_Window_draw_overlay" "', argument " "1"" of type '" "Fl_Overlay_Window *""'"); 
  }
  arg1 = (Fl_Overlay_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Fl_Overlay_Window::draw_overlay");
        } else {
          (arg1)->draw_overlay();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Overlay_Window_hide(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Overlay_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Overlay_Window_hide" "', argument " "1"" of type '" "Fl_Overlay_Window *""'"); 
  }
  arg1 = (Fl_Overlay_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Overlay_Window::hide();
        } else {
          (arg1)->hide();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Overlay_Window_flush(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Overlay_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Overlay_Window_flush" "', argument " "1"" of type '" "Fl_Overlay_Window *""'"); 
  }
  arg1 = (Fl_Overlay_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Overlay_Window::flush();
        } else {
          (arg1)->flush();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Overlay_Window_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Overlay_Window_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Overlay_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Overlay_Window_resize" "', argument " "1"" of type '" "Fl_Overlay_Window *""'"); 
  }
  arg1 = (Fl_Overlay_Window *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Overlay_Window_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Overlay_Window_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Overlay_Window_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Overlay_Window_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Overlay_Window::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Overlay_Window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Overlay_Window, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Overlay_Window" "', argument " "1"" of type '" "Fl_Overlay_Window *""'"); 
  }
  arg1 = (Fl_Overlay_Window *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Overlay_Window_can_do_overlay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 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_Fl_Overlay_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Overlay_Window_can_do_overlay" "', argument " "1"" of type '" "Fl_Overlay_Window *""'"); 
  }
  arg1 = (Fl_Overlay_Window *)(argp1);
  {
    try {
      result = (int)(arg1)->can_do_overlay(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Overlay_Window_redraw_overlay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Overlay_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Overlay_Window_redraw_overlay" "', argument " "1"" of type '" "Fl_Overlay_Window *""'"); 
  }
  arg1 = (Fl_Overlay_Window *)(argp1);
  {
    try {
      (arg1)->redraw_overlay(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Overlay_Window__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  char *arg4 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  Fl_Overlay_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Overlay_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Overlay_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  if (swig_obj[3]) {
    res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Fl_Overlay_Window" "', argument " "4"" of type '" "char const *""'");
    }
    arg4 = (char *)(buf4);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Overlay_Window *)new SwigDirector_Fl_Overlay_Window(arg1,arg2,arg3,(char const *)arg4); 
      } else {
        SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
        SWIG_fail;
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Overlay_Window, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Overlay_Window__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  Fl_Overlay_Window *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Overlay_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Overlay_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Overlay_Window" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Overlay_Window" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Overlay_Window" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Overlay_Window *)new SwigDirector_Fl_Overlay_Window(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
        SWIG_fail;
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Overlay_Window, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Overlay_Window(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_Overlay_Window", 0, 6, argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    PyObject *retobj = _wrap_new_Fl_Overlay_Window__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 5) && (argc <= 6)) {
    PyObject *retobj = _wrap_new_Fl_Overlay_Window__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_Overlay_Window'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Overlay_Window::Fl_Overlay_Window(int,int,char const *)\n"
    "    Fl_Overlay_Window::Fl_Overlay_Window(PyObject *,int,int,int,int,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Overlay_Window_as_overlay_window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Overlay_Window *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Overlay_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Overlay_Window_as_overlay_window" "', argument " "1"" of type '" "Fl_Overlay_Window *""'"); 
  }
  arg1 = (Fl_Overlay_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Overlay_Window *)(arg1)->Fl_Overlay_Window::as_overlay_window();
        } else {
          result = (Fl_Overlay_Window *)(arg1)->as_overlay_window();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Overlay_Window, 0 |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Overlay_Window_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 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, "Fl_Overlay_Window_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Overlay_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Overlay_Window_init_type" "', argument " "1"" of type '" "Fl_Overlay_Window *""'"); 
  }
  arg1 = (Fl_Overlay_Window *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Overlay_Window_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Overlay_Window_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Overlay_Window_show(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Overlay_Window_show", 1, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Overlay_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Overlay_Window_show" "', argument " "1"" of type '" "Fl_Overlay_Window *""'"); 
  }
  arg1 = (Fl_Overlay_Window *)(argp1);
  if (swig_obj[1]) {
    arg2 = swig_obj[1];
  }
  if (swig_obj[2]) {
    arg3 = swig_obj[2];
  }
  {
    try {
      Fl_Overlay_Window_show(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Overlay_Window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Overlay_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Overlay_Window" "', argument " "1"" of type '" "Fl_Overlay_Window *""'"); 
  }
  arg1 = (Fl_Overlay_Window *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Overlay_Window_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Overlay_Window *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Overlay_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Overlay_Window_draw" "', argument " "1"" of type '" "Fl_Overlay_Window *""'"); 
  }
  arg1 = (Fl_Overlay_Window *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Overlay_Window *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Pack_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pack *arg1 = (Fl_Pack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Pack *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Pack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Pack_draw" "', argument " "1"" of type '" "Fl_Pack *""'"); 
  }
  arg1 = (Fl_Pack *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Pack *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Pack(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Pack *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Pack", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Pack" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Pack" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Pack" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Pack" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Pack" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Pack *)new SwigDirector_Fl_Pack(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Pack *)new Fl_Pack(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Pack, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pack_spacing__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Pack *arg1 = (Fl_Pack *) 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_Fl_Pack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Pack_spacing" "', argument " "1"" of type '" "Fl_Pack const *""'"); 
  }
  arg1 = (Fl_Pack *)(argp1);
  {
    try {
      result = (int)((Fl_Pack const *)arg1)->spacing(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pack_spacing__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Pack *arg1 = (Fl_Pack *) 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_Fl_Pack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Pack_spacing" "', argument " "1"" of type '" "Fl_Pack *""'"); 
  }
  arg1 = (Fl_Pack *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Pack_spacing" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->spacing(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pack_spacing(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Pack_spacing", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Pack_spacing__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Pack_spacing__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Pack_spacing'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Pack::spacing() const\n"
    "    Fl_Pack::spacing(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Pack_horizontal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pack *arg1 = (Fl_Pack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  uchar result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Pack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Pack_horizontal" "', argument " "1"" of type '" "Fl_Pack const *""'"); 
  }
  arg1 = (Fl_Pack *)(argp1);
  {
    try {
      result = (uchar)((Fl_Pack const *)arg1)->horizontal(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pack_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pack *arg1 = (Fl_Pack *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Pack_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Pack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Pack_resize" "', argument " "1"" of type '" "Fl_Pack *""'"); 
  }
  arg1 = (Fl_Pack *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Pack_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Pack_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Pack_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Pack_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Pack::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pack_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pack *arg1 = (Fl_Pack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Pack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Pack_clear" "', argument " "1"" of type '" "Fl_Pack *""'"); 
  }
  arg1 = (Fl_Pack *)(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pack_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pack *arg1 = (Fl_Pack *) 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, "Fl_Pack_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Pack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Pack_init_type" "', argument " "1"" of type '" "Fl_Pack *""'"); 
  }
  arg1 = (Fl_Pack *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Pack_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Pack_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Pack(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pack *arg1 = (Fl_Pack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Pack, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Pack" "', argument " "1"" of type '" "Fl_Pack *""'"); 
  }
  arg1 = (Fl_Pack *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Pack(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pack *arg1 = (Fl_Pack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Pack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Pack" "', argument " "1"" of type '" "Fl_Pack *""'"); 
  }
  arg1 = (Fl_Pack *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_PNG_Image__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  Fl_PNG_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_PNG_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_PNG_Image *)new SwigDirector_Fl_PNG_Image(arg1,(char const *)arg2); 
      } else {
        result = (Fl_PNG_Image *)new Fl_PNG_Image((char const *)arg2); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_PNG_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_PNG_Image__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  unsigned char *arg3 = (unsigned char *) 0 ;
  int arg4 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Fl_PNG_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_PNG_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    /* Check if the input support the buffer protocol */
    Py_buffer view;
    const void * buffer;
    int failure = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_CONTIG_RO);
    if (!failure) {
      // work with array object
      buffer = view.buf;
      PyBuffer_Release(&view);
      arg3 = (uchar *) buffer;
    } else {
      // work with list object
      // clear the error from PyObject_GetBuffer
      PyErr_Clear();
      buffer=0;
      /* Check if is a list */
      if (PyList_Check(swig_obj[2])) {
        Py_ssize_t size = PyList_Size(swig_obj[2]);
        int i = 0;
        arg3 = (uchar *) malloc((size+1)*sizeof(char));
        for (i = 0; i < size; i++) {
          PyObject *o = 	PyList_GetItem(swig_obj[2],i);
          if (PyInt_Check(o))
          arg3[i] = (uchar)PyInt_AsLong(o);
          else {
            PyErr_SetString(PyExc_TypeError,"list must contain ints");
            free(arg3);
            return NULL;
          }
        }
        arg3[i] = 0;
      } else {
        PyErr_SetString(PyExc_TypeError,"not a list or does not support single-segment readable buffer interface");
        return NULL;
      }
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_PNG_Image" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_PNG_Image *)new SwigDirector_Fl_PNG_Image(arg1,(char const *)arg2,(unsigned char const *)arg3,arg4); 
      } else {
        result = (Fl_PNG_Image *)new Fl_PNG_Image((char const *)arg2,(unsigned char const *)arg3,arg4); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_PNG_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_PNG_Image(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_PNG_Image", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Fl_PNG_Image__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_Fl_PNG_Image__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_PNG_Image'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_PNG_Image::Fl_PNG_Image(char const *)\n"
    "    Fl_PNG_Image::Fl_PNG_Image(PyObject *,char const *,unsigned char const *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_PNG_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PNG_Image *arg1 = (Fl_PNG_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PNG_Image, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_PNG_Image" "', argument " "1"" of type '" "Fl_PNG_Image *""'"); 
  }
  arg1 = (Fl_PNG_Image *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_PNG_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PNG_Image *arg1 = (Fl_PNG_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PNG_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_PNG_Image" "', argument " "1"" of type '" "Fl_PNG_Image *""'"); 
  }
  arg1 = (Fl_PNG_Image *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_fl_write_png__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  Fl_RGB_Image *arg2 = (Fl_RGB_Image *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (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 '" "fl_write_png" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_write_png" "', argument " "2"" of type '" "Fl_RGB_Image *""'"); 
  }
  arg2 = (Fl_RGB_Image *)(argp2);
  {
    try {
      result = (int)fl_write_png((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_write_png__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 = (int) 3 ;
  int arg6 = (int) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_write_png" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_write_png" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_write_png" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_write_png" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_write_png" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = (int)(val5);
  }
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_write_png" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  {
    try {
      result = (int)fl_write_png((char const *)arg1,(char const *)arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_write_png__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  unsigned char *arg2 = (unsigned char *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 = (int) 3 ;
  int arg6 = (int) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_write_png" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_write_png" "', argument " "2"" of type '" "unsigned char const *""'"); 
  }
  arg2 = (unsigned char *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_write_png" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_write_png" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_write_png" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = (int)(val5);
  }
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_write_png" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  {
    try {
      result = (int)fl_write_png((char const *)arg1,(unsigned char const *)arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_write_png(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fl_write_png", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_fl_write_png__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 4) && (argc <= 6)) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    PyObject *retobj = _wrap_fl_write_png__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_2:
  
  if ((argc >= 4) && (argc <= 6)) {
    PyObject *retobj = _wrap_fl_write_png__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fl_write_png'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    fl_write_png(char const *,Fl_RGB_Image *)\n"
    "    fl_write_png(char const *,char const *,int,int,int,int)\n"
    "    fl_write_png(char const *,unsigned char const *,int,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Fl_PNM_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Fl_PNM_Image *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_PNM_Image", 2, 2, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_PNM_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_PNM_Image *)new SwigDirector_Fl_PNM_Image(arg1,(char const *)arg2); 
      } else {
        result = (Fl_PNM_Image *)new Fl_PNM_Image((char const *)arg2); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_PNM_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_PNM_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PNM_Image *arg1 = (Fl_PNM_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PNM_Image, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_PNM_Image" "', argument " "1"" of type '" "Fl_PNM_Image *""'"); 
  }
  arg1 = (Fl_PNM_Image *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_PNM_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PNM_Image *arg1 = (Fl_PNM_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PNM_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_PNM_Image" "', argument " "1"" of type '" "Fl_PNM_Image *""'"); 
  }
  arg1 = (Fl_PNM_Image *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Positioner_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Positioner *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_draw" "', argument " "1"" of type '" "Fl_Positioner *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Positioner *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Positioner_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_handle" "', argument " "1"" of type '" "Fl_Positioner *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Positioner::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Positioner(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Positioner *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Positioner", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Positioner" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Positioner" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Positioner" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Positioner" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Positioner" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Positioner *)new SwigDirector_Fl_Positioner(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Positioner *)new Fl_Positioner(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Positioner, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_xvalue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 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_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_xvalue" "', argument " "1"" of type '" "Fl_Positioner const *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  {
    try {
      result = (double)((Fl_Positioner const *)arg1)->xvalue(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_yvalue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 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_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_yvalue" "', argument " "1"" of type '" "Fl_Positioner const *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  {
    try {
      result = (double)((Fl_Positioner const *)arg1)->yvalue(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_xvalue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_xvalue" "', argument " "1"" of type '" "Fl_Positioner *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_xvalue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      result = (int)(arg1)->xvalue(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_xvalue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Positioner_xvalue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Positioner_xvalue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Positioner_xvalue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Positioner_xvalue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Positioner::xvalue() const\n"
    "    Fl_Positioner::xvalue(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_yvalue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_yvalue" "', argument " "1"" of type '" "Fl_Positioner *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_yvalue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      result = (int)(arg1)->yvalue(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_yvalue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Positioner_yvalue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Positioner_yvalue__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Positioner_yvalue__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Positioner_yvalue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Positioner::yvalue() const\n"
    "    Fl_Positioner::yvalue(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Positioner_value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_value" "', argument " "1"" of type '" "Fl_Positioner *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_value" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Positioner_value" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  {
    try {
      result = (int)(arg1)->value(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_xbounds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Positioner_xbounds", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_xbounds" "', argument " "1"" of type '" "Fl_Positioner *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_xbounds" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Positioner_xbounds" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  {
    try {
      (arg1)->xbounds(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_xminimum__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 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_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_xminimum" "', argument " "1"" of type '" "Fl_Positioner const *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  {
    try {
      result = (double)((Fl_Positioner const *)arg1)->xminimum(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_xminimum__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 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_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_xminimum" "', argument " "1"" of type '" "Fl_Positioner *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_xminimum" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      (arg1)->xminimum(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_xminimum(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Positioner_xminimum", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Positioner_xminimum__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Positioner_xminimum__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Positioner_xminimum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Positioner::xminimum() const\n"
    "    Fl_Positioner::xminimum(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_xmaximum__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 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_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_xmaximum" "', argument " "1"" of type '" "Fl_Positioner const *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  {
    try {
      result = (double)((Fl_Positioner const *)arg1)->xmaximum(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_xmaximum__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 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_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_xmaximum" "', argument " "1"" of type '" "Fl_Positioner *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_xmaximum" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      (arg1)->xmaximum(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_xmaximum(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Positioner_xmaximum", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Positioner_xmaximum__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Positioner_xmaximum__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Positioner_xmaximum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Positioner::xmaximum() const\n"
    "    Fl_Positioner::xmaximum(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_ybounds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Positioner_ybounds", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_ybounds" "', argument " "1"" of type '" "Fl_Positioner *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_ybounds" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Positioner_ybounds" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  {
    try {
      (arg1)->ybounds(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_yminimum__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 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_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_yminimum" "', argument " "1"" of type '" "Fl_Positioner const *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  {
    try {
      result = (double)((Fl_Positioner const *)arg1)->yminimum(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_yminimum__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 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_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_yminimum" "', argument " "1"" of type '" "Fl_Positioner *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_yminimum" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      (arg1)->yminimum(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_yminimum(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Positioner_yminimum", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Positioner_yminimum__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Positioner_yminimum__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Positioner_yminimum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Positioner::yminimum() const\n"
    "    Fl_Positioner::yminimum(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_ymaximum__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 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_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_ymaximum" "', argument " "1"" of type '" "Fl_Positioner const *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  {
    try {
      result = (double)((Fl_Positioner const *)arg1)->ymaximum(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_ymaximum__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 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_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_ymaximum" "', argument " "1"" of type '" "Fl_Positioner *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_ymaximum" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      (arg1)->ymaximum(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_ymaximum(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Positioner_ymaximum", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Positioner_ymaximum__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Positioner_ymaximum__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Positioner_ymaximum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Positioner::ymaximum() const\n"
    "    Fl_Positioner::ymaximum(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_xstep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 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, "Fl_Positioner_xstep", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_xstep" "', argument " "1"" of type '" "Fl_Positioner *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_xstep" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      (arg1)->xstep(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_ystep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 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, "Fl_Positioner_ystep", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_ystep" "', argument " "1"" of type '" "Fl_Positioner *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_ystep" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      (arg1)->ystep(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 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, "Fl_Positioner_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Positioner_init_type" "', argument " "1"" of type '" "Fl_Positioner *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Positioner_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Positioner_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Positioner(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Positioner, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Positioner" "', argument " "1"" of type '" "Fl_Positioner *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Positioner(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Positioner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Positioner" "', argument " "1"" of type '" "Fl_Positioner *""'"); 
  }
  arg1 = (Fl_Positioner *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Preferences__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Preferences::Root arg1 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Fl_Preferences *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Fl_Preferences" "', argument " "1"" of type '" "Fl_Preferences::Root""'");
  } 
  arg1 = (Fl_Preferences::Root)(val1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_Preferences" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fl_Preferences" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      result = (Fl_Preferences *)new Fl_Preferences(arg1,(char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Preferences, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Preferences__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  Fl_Preferences *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Preferences,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fl_Preferences" "', argument " "1"" of type '" "Fl_Preferences &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Fl_Preferences" "', argument " "1"" of type '" "Fl_Preferences &""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_Preferences" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (Fl_Preferences *)new Fl_Preferences(*arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Preferences, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Preferences(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_Preferences", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Fl_Preferences__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_Fl_Preferences__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_Preferences'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Preferences::Fl_Preferences(Fl_Preferences::Root,char const *,char const *)\n"
    "    Fl_Preferences::Fl_Preferences(Fl_Preferences &,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Preferences(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Preferences" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_groups(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 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_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_groups" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  {
    try {
      result = (int)(arg1)->groups(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_group(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 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, "Fl_Preferences_group", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_group" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Preferences_group" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (char *)(arg1)->group(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_groupExists(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Preferences_groupExists", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_groupExists" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Preferences_groupExists" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (char)(arg1)->groupExists((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_deleteGroup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Preferences_deleteGroup", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_deleteGroup" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Preferences_deleteGroup" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (char)(arg1)->deleteGroup((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_entries(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 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_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_entries" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  {
    try {
      result = (int)(arg1)->entries(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_entry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 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, "Fl_Preferences_entry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_entry" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Preferences_entry" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (char *)(arg1)->entry(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_entryExists(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Preferences_entryExists", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_entryExists" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Preferences_entryExists" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (char)(arg1)->entryExists((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_deleteEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Preferences_deleteEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_deleteEntry" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Preferences_deleteEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (char)(arg1)->deleteEntry((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_set" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Preferences_set" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Preferences_set" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (char)(arg1)->set((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  char *arg2 = (char *) 0 ;
  float arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_set" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Preferences_set" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Preferences_set" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = (float)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Preferences_set" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      result = (char)(arg1)->set((char const *)arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_set__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  char *arg2 = (char *) 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_set" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Preferences_set" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Preferences_set" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  {
    try {
      result = (char)(arg1)->set((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_set__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  char *arg2 = (char *) 0 ;
  double arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_set" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Preferences_set" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Preferences_set" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Preferences_set" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      result = (char)(arg1)->set((char const *)arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_set__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_set" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Preferences_set" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Preferences_set" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      result = (char)(arg1)->set((char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_set__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = (void *) 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  int val4 ;
  int ecode4 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_set" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Preferences_set" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Preferences_set" "', argument " "3"" of type '" "void const *""'"); 
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Preferences_set" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      result = (char)(arg1)->set((char const *)arg2,(void const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Preferences_set", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Preferences_set__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_double(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_Fl_Preferences_set__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Preferences_set__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    PyObject *retobj = _wrap_Fl_Preferences_set__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_4:
  
  if (argc == 4) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_float(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    PyObject *retobj = _wrap_Fl_Preferences_set__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_5:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_Fl_Preferences_set__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Preferences_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Preferences::set(char const *,int)\n"
    "    Fl_Preferences::set(char const *,float,int)\n"
    "    Fl_Preferences::set(char const *,double)\n"
    "    Fl_Preferences::set(char const *,double,int)\n"
    "    Fl_Preferences::set(char const *,char const *)\n"
    "    Fl_Preferences::set(char const *,void const *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_get__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  char *arg2 = (char *) 0 ;
  int *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  char result;
  
  arg3 = &temp3;
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_get" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Preferences_get" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Preferences_get" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      result = (char)(arg1)->get((char const *)arg2,*arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 0);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_get__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  char *arg2 = (char *) 0 ;
  float *arg3 = 0 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  char result;
  
  arg3 = &temp3;
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_get" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Preferences_get" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode4 = SWIG_AsVal_float(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Preferences_get" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = (float)(val4);
  {
    try {
      result = (char)(arg1)->get((char const *)arg2,*arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 0);
  } 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), 0);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_get__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  char *arg2 = (char *) 0 ;
  double *arg3 = 0 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  double temp3 ;
  int res3 = SWIG_TMPOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  char result;
  
  arg3 = &temp3;
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_get" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Preferences_get" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Preferences_get" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = (double)(val4);
  {
    try {
      result = (char)(arg1)->get((char const *)arg2,*arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 0);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_get__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  char temp3[1024+1] ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  char result;
  
  arg3 = (char *) temp3;
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_get" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Preferences_get" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Preferences_get" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = (char *)(buf4);
  ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Preferences_get" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      result = (char)(arg1)->get((char const *)arg2,arg3,(char const *)arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  arg3[1024] = 0;  
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg3), 0);
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_get__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = (void *) 0 ;
  void *arg4 = (void *) 0 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  int res4 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_get" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Preferences_get" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Preferences_get" "', argument " "3"" of type '" "void *""'"); 
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Preferences_get" "', argument " "4"" of type '" "void const *""'"); 
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Preferences_get" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Preferences_get" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  {
    try {
      result = (char)(arg1)->get((char const *)arg2,arg3,(void const *)arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Preferences_get", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Preferences_get__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_float(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_Fl_Preferences_get__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Preferences_get__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_Fl_Preferences_get__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_Fl_Preferences_get__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Preferences_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Preferences::get(char const *,int &,int)\n"
    "    Fl_Preferences::get(char const *,float &,float)\n"
    "    Fl_Preferences::get(char const *,double &,double)\n"
    "    Fl_Preferences::get(char const *,char *,char const *,int)\n"
    "    Fl_Preferences::get(char const *,void *,void const *,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  char *arg2 = (char *) 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, "Fl_Preferences_size", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_size" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Preferences_size" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)(arg1)->size((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_getUserdataPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t size2 ;
  char *buff2 = 0 ;
  PyObject *swig_obj[2] ;
  char result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Preferences_getUserdataPath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_getUserdataPath" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  res2 = SWIG_AsVal_size_t (swig_obj[1], &size2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Preferences_getUserdataPath" "', argument " "2"" of type '" "(char *path, int pathlen)""'");
  }
  buff2= (new char[size2+1]());
  arg3 = (int)(size2);
  arg2 = (char *)(buff2);
  {
    try {
      result = (char)(arg1)->getUserdataPath(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg2), 0);
  if (buff2) delete[] buff2;
  return resultobj;
fail:
  if (buff2) delete[] buff2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_flush(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Preferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Preferences_flush" "', argument " "1"" of type '" "Fl_Preferences *""'"); 
  }
  arg1 = (Fl_Preferences *)(argp1);
  {
    try {
      (arg1)->flush(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Progress_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Progress *arg1 = (Fl_Progress *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Progress *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Progress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Progress_draw" "', argument " "1"" of type '" "Fl_Progress *""'"); 
  }
  arg1 = (Fl_Progress *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Progress *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Progress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Progress *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Progress", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Progress" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Progress" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Progress" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Progress" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Progress" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Progress *)new SwigDirector_Fl_Progress(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Progress *)new Fl_Progress(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Progress, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Progress_maximum__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Progress *arg1 = (Fl_Progress *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Progress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Progress_maximum" "', argument " "1"" of type '" "Fl_Progress *""'"); 
  }
  arg1 = (Fl_Progress *)(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Progress_maximum" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = (float)(val2);
  {
    try {
      (arg1)->maximum(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Progress_maximum__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Progress *arg1 = (Fl_Progress *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Progress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Progress_maximum" "', argument " "1"" of type '" "Fl_Progress const *""'"); 
  }
  arg1 = (Fl_Progress *)(argp1);
  {
    try {
      result = (float)((Fl_Progress const *)arg1)->maximum(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_float((float)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Progress_maximum(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Progress_maximum", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Progress_maximum__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Progress_maximum__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Progress_maximum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Progress::maximum(float)\n"
    "    Fl_Progress::maximum() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Progress_minimum__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Progress *arg1 = (Fl_Progress *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Progress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Progress_minimum" "', argument " "1"" of type '" "Fl_Progress *""'"); 
  }
  arg1 = (Fl_Progress *)(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Progress_minimum" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = (float)(val2);
  {
    try {
      (arg1)->minimum(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Progress_minimum__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Progress *arg1 = (Fl_Progress *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Progress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Progress_minimum" "', argument " "1"" of type '" "Fl_Progress const *""'"); 
  }
  arg1 = (Fl_Progress *)(argp1);
  {
    try {
      result = (float)((Fl_Progress const *)arg1)->minimum(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_float((float)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Progress_minimum(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Progress_minimum", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Progress_minimum__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Progress_minimum__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Progress_minimum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Progress::minimum(float)\n"
    "    Fl_Progress::minimum() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Progress_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Progress *arg1 = (Fl_Progress *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Progress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Progress_value" "', argument " "1"" of type '" "Fl_Progress *""'"); 
  }
  arg1 = (Fl_Progress *)(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Progress_value" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = (float)(val2);
  {
    try {
      (arg1)->value(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Progress_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Progress *arg1 = (Fl_Progress *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Progress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Progress_value" "', argument " "1"" of type '" "Fl_Progress const *""'"); 
  }
  arg1 = (Fl_Progress *)(argp1);
  {
    try {
      result = (float)((Fl_Progress const *)arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_float((float)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Progress_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Progress_value", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Progress_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Progress_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Progress_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Progress::value(float)\n"
    "    Fl_Progress::value() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Progress_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Progress *arg1 = (Fl_Progress *) 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, "Fl_Progress_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Progress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Progress_init_type" "', argument " "1"" of type '" "Fl_Progress *""'"); 
  }
  arg1 = (Fl_Progress *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Progress_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Progress_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Progress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Progress *arg1 = (Fl_Progress *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Progress, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Progress" "', argument " "1"" of type '" "Fl_Progress *""'"); 
  }
  arg1 = (Fl_Progress *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Progress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Progress *arg1 = (Fl_Progress *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Progress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Progress" "', argument " "1"" of type '" "Fl_Progress *""'"); 
  }
  arg1 = (Fl_Progress *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Radio_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Radio_Button *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Radio_Button", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Radio_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Radio_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Radio_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Radio_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Radio_Button" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Radio_Button *)new SwigDirector_Fl_Radio_Button(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Radio_Button *)new Fl_Radio_Button(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Radio_Button, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Radio_Button_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Button *arg1 = (Fl_Radio_Button *) 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, "Fl_Radio_Button_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Radio_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Radio_Button_init_type" "', argument " "1"" of type '" "Fl_Radio_Button *""'"); 
  }
  arg1 = (Fl_Radio_Button *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Radio_Button_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Radio_Button_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Radio_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Button *arg1 = (Fl_Radio_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Radio_Button, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Radio_Button" "', argument " "1"" of type '" "Fl_Radio_Button *""'"); 
  }
  arg1 = (Fl_Radio_Button *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Radio_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Button *arg1 = (Fl_Radio_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Radio_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Radio_Button" "', argument " "1"" of type '" "Fl_Radio_Button *""'"); 
  }
  arg1 = (Fl_Radio_Button *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Radio_Button_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Button *arg1 = (Fl_Radio_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Radio_Button *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Radio_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Radio_Button_draw" "', argument " "1"" of type '" "Fl_Radio_Button *""'"); 
  }
  arg1 = (Fl_Radio_Button *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Radio_Button *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Radio_Light_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Radio_Light_Button *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Radio_Light_Button", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Radio_Light_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Radio_Light_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Radio_Light_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Radio_Light_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Radio_Light_Button" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Radio_Light_Button *)new SwigDirector_Fl_Radio_Light_Button(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Radio_Light_Button *)new Fl_Radio_Light_Button(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Radio_Light_Button, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Radio_Light_Button_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Light_Button *arg1 = (Fl_Radio_Light_Button *) 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, "Fl_Radio_Light_Button_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Radio_Light_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Radio_Light_Button_init_type" "', argument " "1"" of type '" "Fl_Radio_Light_Button *""'"); 
  }
  arg1 = (Fl_Radio_Light_Button *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Radio_Light_Button_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Radio_Light_Button_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Radio_Light_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Light_Button *arg1 = (Fl_Radio_Light_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Radio_Light_Button, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Radio_Light_Button" "', argument " "1"" of type '" "Fl_Radio_Light_Button *""'"); 
  }
  arg1 = (Fl_Radio_Light_Button *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Radio_Light_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Light_Button *arg1 = (Fl_Radio_Light_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Radio_Light_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Radio_Light_Button" "', argument " "1"" of type '" "Fl_Radio_Light_Button *""'"); 
  }
  arg1 = (Fl_Radio_Light_Button *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Radio_Light_Button_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Light_Button *arg1 = (Fl_Radio_Light_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Radio_Light_Button *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Radio_Light_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Radio_Light_Button_draw" "', argument " "1"" of type '" "Fl_Radio_Light_Button *""'"); 
  }
  arg1 = (Fl_Radio_Light_Button *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Radio_Light_Button *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Round_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Round_Button *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Round_Button", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Round_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Round_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Round_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Round_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Round_Button" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Round_Button *)new SwigDirector_Fl_Round_Button(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Round_Button *)new Fl_Round_Button(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Round_Button, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Round_Button_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Round_Button *arg1 = (Fl_Round_Button *) 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, "Fl_Round_Button_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Round_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Round_Button_init_type" "', argument " "1"" of type '" "Fl_Round_Button *""'"); 
  }
  arg1 = (Fl_Round_Button *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Round_Button_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Round_Button_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Round_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Round_Button *arg1 = (Fl_Round_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Round_Button, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Round_Button" "', argument " "1"" of type '" "Fl_Round_Button *""'"); 
  }
  arg1 = (Fl_Round_Button *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Round_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Round_Button *arg1 = (Fl_Round_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Round_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Round_Button" "', argument " "1"" of type '" "Fl_Round_Button *""'"); 
  }
  arg1 = (Fl_Round_Button *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Round_Button_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Round_Button *arg1 = (Fl_Round_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Round_Button *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Round_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Round_Button_draw" "', argument " "1"" of type '" "Fl_Round_Button *""'"); 
  }
  arg1 = (Fl_Round_Button *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Round_Button *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Radio_Round_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Radio_Round_Button *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Radio_Round_Button", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Radio_Round_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Radio_Round_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Radio_Round_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Radio_Round_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Radio_Round_Button" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Radio_Round_Button *)new SwigDirector_Fl_Radio_Round_Button(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Radio_Round_Button *)new Fl_Radio_Round_Button(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Radio_Round_Button, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Radio_Round_Button_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Round_Button *arg1 = (Fl_Radio_Round_Button *) 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, "Fl_Radio_Round_Button_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Radio_Round_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Radio_Round_Button_init_type" "', argument " "1"" of type '" "Fl_Radio_Round_Button *""'"); 
  }
  arg1 = (Fl_Radio_Round_Button *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Radio_Round_Button_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Radio_Round_Button_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Radio_Round_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Round_Button *arg1 = (Fl_Radio_Round_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Radio_Round_Button, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Radio_Round_Button" "', argument " "1"" of type '" "Fl_Radio_Round_Button *""'"); 
  }
  arg1 = (Fl_Radio_Round_Button *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Radio_Round_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Round_Button *arg1 = (Fl_Radio_Round_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Radio_Round_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Radio_Round_Button" "', argument " "1"" of type '" "Fl_Radio_Round_Button *""'"); 
  }
  arg1 = (Fl_Radio_Round_Button *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Radio_Round_Button_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Round_Button *arg1 = (Fl_Radio_Round_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Radio_Round_Button *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Radio_Round_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Radio_Round_Button_draw" "', argument " "1"" of type '" "Fl_Radio_Round_Button *""'"); 
  }
  arg1 = (Fl_Radio_Round_Button *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Radio_Round_Button *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Repeat_Button_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Repeat_Button *arg1 = (Fl_Repeat_Button *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Repeat_Button_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Repeat_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Repeat_Button_handle" "', argument " "1"" of type '" "Fl_Repeat_Button *""'"); 
  }
  arg1 = (Fl_Repeat_Button *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Repeat_Button_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Repeat_Button::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Repeat_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Repeat_Button *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Repeat_Button", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Repeat_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Repeat_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Repeat_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Repeat_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Repeat_Button" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Repeat_Button *)new SwigDirector_Fl_Repeat_Button(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Repeat_Button *)new Fl_Repeat_Button(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Repeat_Button, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Repeat_Button_deactivate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Repeat_Button *arg1 = (Fl_Repeat_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Repeat_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Repeat_Button_deactivate" "', argument " "1"" of type '" "Fl_Repeat_Button *""'"); 
  }
  arg1 = (Fl_Repeat_Button *)(argp1);
  {
    try {
      (arg1)->deactivate(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Repeat_Button_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Repeat_Button *arg1 = (Fl_Repeat_Button *) 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, "Fl_Repeat_Button_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Repeat_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Repeat_Button_init_type" "', argument " "1"" of type '" "Fl_Repeat_Button *""'"); 
  }
  arg1 = (Fl_Repeat_Button *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Repeat_Button_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Repeat_Button_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Repeat_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Repeat_Button *arg1 = (Fl_Repeat_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Repeat_Button, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Repeat_Button" "', argument " "1"" of type '" "Fl_Repeat_Button *""'"); 
  }
  arg1 = (Fl_Repeat_Button *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Repeat_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Repeat_Button *arg1 = (Fl_Repeat_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Repeat_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Repeat_Button" "', argument " "1"" of type '" "Fl_Repeat_Button *""'"); 
  }
  arg1 = (Fl_Repeat_Button *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Repeat_Button_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Repeat_Button *arg1 = (Fl_Repeat_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Repeat_Button *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Repeat_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Repeat_Button_draw" "', argument " "1"" of type '" "Fl_Repeat_Button *""'"); 
  }
  arg1 = (Fl_Repeat_Button *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Repeat_Button *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Return_Button_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Return_Button *arg1 = (Fl_Return_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Return_Button *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Return_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Return_Button_draw" "', argument " "1"" of type '" "Fl_Return_Button *""'"); 
  }
  arg1 = (Fl_Return_Button *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Return_Button *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Return_Button_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Return_Button *arg1 = (Fl_Return_Button *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Return_Button_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Return_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Return_Button_handle" "', argument " "1"" of type '" "Fl_Return_Button *""'"); 
  }
  arg1 = (Fl_Return_Button *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Return_Button_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Return_Button::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Return_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Return_Button *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Return_Button", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Return_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Return_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Return_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Return_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Return_Button" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Return_Button *)new SwigDirector_Fl_Return_Button(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Return_Button *)new Fl_Return_Button(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Return_Button, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Return_Button_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Return_Button *arg1 = (Fl_Return_Button *) 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, "Fl_Return_Button_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Return_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Return_Button_init_type" "', argument " "1"" of type '" "Fl_Return_Button *""'"); 
  }
  arg1 = (Fl_Return_Button *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Return_Button_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Return_Button_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Return_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Return_Button *arg1 = (Fl_Return_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Return_Button, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Return_Button" "', argument " "1"" of type '" "Fl_Return_Button *""'"); 
  }
  arg1 = (Fl_Return_Button *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Return_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Return_Button *arg1 = (Fl_Return_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Return_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Return_Button" "', argument " "1"" of type '" "Fl_Return_Button *""'"); 
  }
  arg1 = (Fl_Return_Button *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Rect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Fl_Rect *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Fl_Rect *)new Fl_Rect(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Rect, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Rect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Fl_Rect *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_Fl_Rect" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Rect" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (Fl_Rect *)new Fl_Rect(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Rect, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Rect__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Fl_Rect *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Fl_Rect" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Rect" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Rect" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Rect" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      result = (Fl_Rect *)new Fl_Rect(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Rect, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Rect__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  Fl_Boxtype arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Fl_Rect *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Fl_Rect" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Rect" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Rect" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Rect" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Rect" "', argument " "5"" of type '" "Fl_Boxtype""'");
  } 
  arg5 = (Fl_Boxtype)(val5);
  {
    try {
      result = (Fl_Rect *)new Fl_Rect(arg1,arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Rect, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Rect__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Rect *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Fl_Widget,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fl_Rect" "', argument " "1"" of type '" "Fl_Widget const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Fl_Rect" "', argument " "1"" of type '" "Fl_Widget const &""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (Fl_Rect *)new Fl_Rect((Fl_Widget const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Rect, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Rect__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) (Fl_Widget *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Rect *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fl_Rect" "', argument " "1"" of type '" "Fl_Widget const *const""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      result = (Fl_Rect *)new Fl_Rect((Fl_Widget const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Rect, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Rect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_Rect", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_Fl_Rect__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Fl_Widget, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_Fl_Rect__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_Fl_Rect__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Fl_Rect__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_Fl_Rect__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_new_Fl_Rect__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_Rect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Rect::Fl_Rect()\n"
    "    Fl_Rect::Fl_Rect(int,int)\n"
    "    Fl_Rect::Fl_Rect(int,int,int,int)\n"
    "    Fl_Rect::Fl_Rect(int,int,int,int,Fl_Boxtype)\n"
    "    Fl_Rect::Fl_Rect(Fl_Widget const &)\n"
    "    Fl_Rect::Fl_Rect(Fl_Widget const *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_x__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Rect *arg1 = (Fl_Rect *) 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_Fl_Rect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Rect_x" "', argument " "1"" of type '" "Fl_Rect const *""'"); 
  }
  arg1 = (Fl_Rect *)(argp1);
  {
    try {
      result = (int)((Fl_Rect const *)arg1)->x(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_y__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Rect *arg1 = (Fl_Rect *) 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_Fl_Rect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Rect_y" "', argument " "1"" of type '" "Fl_Rect const *""'"); 
  }
  arg1 = (Fl_Rect *)(argp1);
  {
    try {
      result = (int)((Fl_Rect const *)arg1)->y(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_w__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Rect *arg1 = (Fl_Rect *) 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_Fl_Rect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Rect_w" "', argument " "1"" of type '" "Fl_Rect const *""'"); 
  }
  arg1 = (Fl_Rect *)(argp1);
  {
    try {
      result = (int)((Fl_Rect const *)arg1)->w(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_h__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Rect *arg1 = (Fl_Rect *) 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_Fl_Rect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Rect_h" "', argument " "1"" of type '" "Fl_Rect const *""'"); 
  }
  arg1 = (Fl_Rect *)(argp1);
  {
    try {
      result = (int)((Fl_Rect const *)arg1)->h(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_r__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Rect *arg1 = (Fl_Rect *) 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_Fl_Rect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Rect_r" "', argument " "1"" of type '" "Fl_Rect const *""'"); 
  }
  arg1 = (Fl_Rect *)(argp1);
  {
    try {
      result = (int)((Fl_Rect const *)arg1)->r(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_b__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Rect *arg1 = (Fl_Rect *) 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_Fl_Rect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Rect_b" "', argument " "1"" of type '" "Fl_Rect const *""'"); 
  }
  arg1 = (Fl_Rect *)(argp1);
  {
    try {
      result = (int)((Fl_Rect const *)arg1)->b(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_x__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Rect *arg1 = (Fl_Rect *) 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_Fl_Rect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Rect_x" "', argument " "1"" of type '" "Fl_Rect *""'"); 
  }
  arg1 = (Fl_Rect *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Rect_x" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->x(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_x(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Rect_x", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Rect_x__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Rect_x__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Rect_x'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Rect::x() const\n"
    "    Fl_Rect::x(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_y__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Rect *arg1 = (Fl_Rect *) 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_Fl_Rect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Rect_y" "', argument " "1"" of type '" "Fl_Rect *""'"); 
  }
  arg1 = (Fl_Rect *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Rect_y" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->y(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_y(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Rect_y", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Rect_y__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Rect_y__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Rect_y'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Rect::y() const\n"
    "    Fl_Rect::y(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_w__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Rect *arg1 = (Fl_Rect *) 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_Fl_Rect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Rect_w" "', argument " "1"" of type '" "Fl_Rect *""'"); 
  }
  arg1 = (Fl_Rect *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Rect_w" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->w(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_w(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Rect_w", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Rect_w__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Rect_w__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Rect_w'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Rect::w() const\n"
    "    Fl_Rect::w(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_h__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Rect *arg1 = (Fl_Rect *) 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_Fl_Rect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Rect_h" "', argument " "1"" of type '" "Fl_Rect *""'"); 
  }
  arg1 = (Fl_Rect *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Rect_h" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->h(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_h(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Rect_h", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Rect_h__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Rect_h__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Rect_h'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Rect::h() const\n"
    "    Fl_Rect::h(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_r__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Rect *arg1 = (Fl_Rect *) 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_Fl_Rect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Rect_r" "', argument " "1"" of type '" "Fl_Rect *""'"); 
  }
  arg1 = (Fl_Rect *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Rect_r" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->r(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_r(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Rect_r", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Rect_r__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Rect_r__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Rect_r'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Rect::r() const\n"
    "    Fl_Rect::r(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_b__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Rect *arg1 = (Fl_Rect *) 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_Fl_Rect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Rect_b" "', argument " "1"" of type '" "Fl_Rect *""'"); 
  }
  arg1 = (Fl_Rect *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Rect_b" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->b(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_b(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Rect_b", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Rect_b__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Rect_b__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Rect_b'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Rect::b() const\n"
    "    Fl_Rect::b(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_inset__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Rect *arg1 = (Fl_Rect *) 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_Fl_Rect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Rect_inset" "', argument " "1"" of type '" "Fl_Rect *""'"); 
  }
  arg1 = (Fl_Rect *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Rect_inset" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->inset(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_inset__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Rect *arg1 = (Fl_Rect *) 0 ;
  Fl_Boxtype 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_Fl_Rect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Rect_inset" "', argument " "1"" of type '" "Fl_Rect *""'"); 
  }
  arg1 = (Fl_Rect *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Rect_inset" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = (Fl_Boxtype)(val2);
  {
    try {
      (arg1)->inset(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_inset__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Rect *arg1 = (Fl_Rect *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Rect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Rect_inset" "', argument " "1"" of type '" "Fl_Rect *""'"); 
  }
  arg1 = (Fl_Rect *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Rect_inset" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Rect_inset" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Rect_inset" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Rect_inset" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      (arg1)->inset(arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_inset(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Rect_inset", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Rect_inset__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Rect_inset__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_Fl_Rect_inset__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Rect_inset'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Rect::inset(int)\n"
    "    Fl_Rect::inset(Fl_Boxtype)\n"
    "    Fl_Rect::inset(int,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Rect_contains(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Rect *arg1 = (Fl_Rect *) 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] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Rect_contains", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Rect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Rect_contains" "', argument " "1"" of type '" "Fl_Rect const *""'"); 
  }
  arg1 = (Fl_Rect *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Rect_contains" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Rect_contains" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (bool)((Fl_Rect const *)arg1)->contains(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Rect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Rect *arg1 = (Fl_Rect *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Rect, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Rect" "', argument " "1"" of type '" "Fl_Rect *""'"); 
  }
  arg1 = (Fl_Rect *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_SVG_Image__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  Fl_SVG_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_SVG_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_SVG_Image *)new SwigDirector_Fl_SVG_Image(arg1,(char const *)arg2); 
      } else {
        result = (Fl_SVG_Image *)new Fl_SVG_Image((char const *)arg2); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_SVG_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_SVG_Image__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Fl_SVG_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_SVG_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fl_SVG_Image" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_SVG_Image *)new SwigDirector_Fl_SVG_Image(arg1,(char const *)arg2,(char const *)arg3); 
      } else {
        result = (Fl_SVG_Image *)new Fl_SVG_Image((char const *)arg2,(char const *)arg3); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_SVG_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_SVG_Image__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  unsigned char *arg3 = (unsigned char *) 0 ;
  size_t arg4 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  Fl_SVG_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_SVG_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fl_SVG_Image" "', argument " "3"" of type '" "unsigned char const *""'"); 
  }
  arg3 = (unsigned char *)(argp3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_SVG_Image" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = (size_t)(val4);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_SVG_Image *)new SwigDirector_Fl_SVG_Image(arg1,(char const *)arg2,(unsigned char const *)arg3,SWIG_STD_MOVE(arg4)); 
      } else {
        result = (Fl_SVG_Image *)new Fl_SVG_Image((char const *)arg2,(unsigned char const *)arg3,SWIG_STD_MOVE(arg4)); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_SVG_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_SVG_Image(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_SVG_Image", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Fl_SVG_Image__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_Fl_SVG_Image__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_Fl_SVG_Image__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_SVG_Image'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_SVG_Image::Fl_SVG_Image(char const *)\n"
    "    Fl_SVG_Image::Fl_SVG_Image(char const *,char const *)\n"
    "    Fl_SVG_Image::Fl_SVG_Image(PyObject *,char const *,unsigned char const *,size_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_SVG_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_SVG_Image *arg1 = (Fl_SVG_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_SVG_Image, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_SVG_Image" "', argument " "1"" of type '" "Fl_SVG_Image *""'"); 
  }
  arg1 = (Fl_SVG_Image *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_SVG_Image_copy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_SVG_Image *arg1 = (Fl_SVG_Image *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_SVG_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_SVG_Image_copy" "', argument " "1"" of type '" "Fl_SVG_Image const *""'"); 
  }
  arg1 = (Fl_SVG_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_SVG_Image_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_SVG_Image_copy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Image *)((Fl_SVG_Image const *)arg1)->Fl_SVG_Image::copy(arg2,arg3);
        } else {
          result = (Fl_Image *)((Fl_SVG_Image const *)arg1)->copy(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, SWIG_POINTER_OWN |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_SVG_Image_copy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_SVG_Image *arg1 = (Fl_SVG_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_SVG_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_SVG_Image_copy" "', argument " "1"" of type '" "Fl_SVG_Image const *""'"); 
  }
  arg1 = (Fl_SVG_Image *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_SVG_Image const *)arg1)->copy(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_SVG_Image_copy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_SVG_Image_copy", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_SVG_Image_copy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_SVG_Image_copy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_SVG_Image_copy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_SVG_Image::copy(int,int) const\n"
    "    Fl_SVG_Image::copy() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_SVG_Image_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_SVG_Image *arg1 = (Fl_SVG_Image *) 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, "Fl_SVG_Image_resize", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_SVG_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_SVG_Image_resize" "', argument " "1"" of type '" "Fl_SVG_Image *""'"); 
  }
  arg1 = (Fl_SVG_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_SVG_Image_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_SVG_Image_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->resize(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_SVG_Image_desaturate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_SVG_Image *arg1 = (Fl_SVG_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_SVG_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_SVG_Image_desaturate" "', argument " "1"" of type '" "Fl_SVG_Image *""'"); 
  }
  arg1 = (Fl_SVG_Image *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_SVG_Image::desaturate();
        } else {
          (arg1)->desaturate();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_SVG_Image_color_average(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_SVG_Image *arg1 = (Fl_SVG_Image *) 0 ;
  Fl_Color arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_SVG_Image_color_average", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_SVG_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_SVG_Image_color_average" "', argument " "1"" of type '" "Fl_SVG_Image *""'"); 
  }
  arg1 = (Fl_SVG_Image *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_SVG_Image_color_average" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_SVG_Image_color_average" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = (float)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_SVG_Image::color_average(arg2,arg3);
        } else {
          (arg1)->color_average(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_SVG_Image_draw__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_SVG_Image *arg1 = (Fl_SVG_Image *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 = (int) 0 ;
  int arg7 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_SVG_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_SVG_Image_draw" "', argument " "1"" of type '" "Fl_SVG_Image *""'"); 
  }
  arg1 = (Fl_SVG_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_SVG_Image_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_SVG_Image_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_SVG_Image_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_SVG_Image_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_SVG_Image_draw" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_SVG_Image_draw" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_SVG_Image::draw(arg2,arg3,arg4,arg5,arg6,arg7);
        } else {
          (arg1)->draw(arg2,arg3,arg4,arg5,arg6,arg7);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_SVG_Image_draw__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_SVG_Image *arg1 = (Fl_SVG_Image *) 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_Fl_SVG_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_SVG_Image_draw" "', argument " "1"" of type '" "Fl_SVG_Image *""'"); 
  }
  arg1 = (Fl_SVG_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_SVG_Image_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_SVG_Image_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->draw(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_SVG_Image_draw(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_SVG_Image_draw", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_SVG_Image_draw__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 5) && (argc <= 7)) {
    PyObject *retobj = _wrap_Fl_SVG_Image_draw__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_SVG_Image_draw'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_SVG_Image::draw(int,int,int,int,int,int)\n"
    "    Fl_SVG_Image::draw(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_SVG_Image_as_svg_image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_SVG_Image *arg1 = (Fl_SVG_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_SVG_Image *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_SVG_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_SVG_Image_as_svg_image" "', argument " "1"" of type '" "Fl_SVG_Image *""'"); 
  }
  arg1 = (Fl_SVG_Image *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_SVG_Image *)(arg1)->Fl_SVG_Image::as_svg_image();
        } else {
          result = (Fl_SVG_Image *)(arg1)->as_svg_image();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_SVG_Image, 0 |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_SVG_Image_normalize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_SVG_Image *arg1 = (Fl_SVG_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_SVG_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_SVG_Image_normalize" "', argument " "1"" of type '" "Fl_SVG_Image *""'"); 
  }
  arg1 = (Fl_SVG_Image *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_SVG_Image::normalize();
        } else {
          (arg1)->normalize();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_SVG_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_SVG_Image *arg1 = (Fl_SVG_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_SVG_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_SVG_Image" "', argument " "1"" of type '" "Fl_SVG_Image *""'"); 
  }
  arg1 = (Fl_SVG_Image *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_SVG_File_Surface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  FILE *arg3 = (FILE *) 0 ;
  int (*arg4)(FILE *) = (int (*)(FILE *)) NULL ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[4] ;
  Fl_SVG_File_Surface *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_SVG_File_Surface", 3, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Fl_SVG_File_Surface" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_SVG_File_Surface" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fl_SVG_File_Surface" "', argument " "3"" of type '" "FILE *""'"); 
  }
  arg3 = (FILE *)(argp3);
  if (swig_obj[3]) {
    {
      int res = SWIG_ConvertFunctionPtr(swig_obj[3], (void**)(&arg4), SWIGTYPE_p_f_p_FILE__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_Fl_SVG_File_Surface" "', argument " "4"" of type '" "int (*)(FILE *)""'"); 
      }
    }
  }
  {
    try {
      result = (Fl_SVG_File_Surface *)new Fl_SVG_File_Surface(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_SVG_File_Surface, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_SVG_File_Surface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_SVG_File_Surface *arg1 = (Fl_SVG_File_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_SVG_File_Surface, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_SVG_File_Surface" "', argument " "1"" of type '" "Fl_SVG_File_Surface *""'"); 
  }
  arg1 = (Fl_SVG_File_Surface *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_SVG_File_Surface_file(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_SVG_File_Surface *arg1 = (Fl_SVG_File_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FILE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_SVG_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_SVG_File_Surface_file" "', argument " "1"" of type '" "Fl_SVG_File_Surface *""'"); 
  }
  arg1 = (Fl_SVG_File_Surface *)(argp1);
  {
    try {
      result = (FILE *)(arg1)->file(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FILE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_SVG_File_Surface_origin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_SVG_File_Surface *arg1 = (Fl_SVG_File_Surface *) 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_Fl_SVG_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_SVG_File_Surface_origin" "', argument " "1"" of type '" "Fl_SVG_File_Surface *""'"); 
  }
  arg1 = (Fl_SVG_File_Surface *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_SVG_File_Surface_origin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_SVG_File_Surface_origin" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->origin(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_SVG_File_Surface_origin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_SVG_File_Surface *arg1 = (Fl_SVG_File_Surface *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 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_Fl_SVG_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_SVG_File_Surface_origin" "', argument " "1"" of type '" "Fl_SVG_File_Surface *""'"); 
  }
  arg1 = (Fl_SVG_File_Surface *)(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 '" "Fl_SVG_File_Surface_origin" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (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 '" "Fl_SVG_File_Surface_origin" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  {
    try {
      (arg1)->origin(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_SVG_File_Surface_origin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_SVG_File_Surface_origin", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_SVG_File_Surface_origin__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_SVG_File_Surface_origin__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_SVG_File_Surface_origin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_SVG_File_Surface::origin(int,int)\n"
    "    Fl_SVG_File_Surface::origin(int *,int *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_SVG_File_Surface_translate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_SVG_File_Surface *arg1 = (Fl_SVG_File_Surface *) 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, "Fl_SVG_File_Surface_translate", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_SVG_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_SVG_File_Surface_translate" "', argument " "1"" of type '" "Fl_SVG_File_Surface *""'"); 
  }
  arg1 = (Fl_SVG_File_Surface *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_SVG_File_Surface_translate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_SVG_File_Surface_translate" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->translate(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_SVG_File_Surface_untranslate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_SVG_File_Surface *arg1 = (Fl_SVG_File_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_SVG_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_SVG_File_Surface_untranslate" "', argument " "1"" of type '" "Fl_SVG_File_Surface *""'"); 
  }
  arg1 = (Fl_SVG_File_Surface *)(argp1);
  {
    try {
      (arg1)->untranslate(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_SVG_File_Surface_printable_rect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_SVG_File_Surface *arg1 = (Fl_SVG_File_Surface *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_SVG_File_Surface_printable_rect", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_SVG_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_SVG_File_Surface_printable_rect" "', argument " "1"" of type '" "Fl_SVG_File_Surface *""'"); 
  }
  arg1 = (Fl_SVG_File_Surface *)(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 '" "Fl_SVG_File_Surface_printable_rect" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (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 '" "Fl_SVG_File_Surface_printable_rect" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  {
    try {
      result = (int)(arg1)->printable_rect(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_SVG_File_Surface_close(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_SVG_File_Surface *arg1 = (Fl_SVG_File_Surface *) 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_Fl_SVG_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_SVG_File_Surface_close" "', argument " "1"" of type '" "Fl_SVG_File_Surface *""'"); 
  }
  arg1 = (Fl_SVG_File_Surface *)(argp1);
  {
    try {
      result = (int)(arg1)->close(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Roller_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Roller *arg1 = (Fl_Roller *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Roller *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Roller, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Roller_draw" "', argument " "1"" of type '" "Fl_Roller *""'"); 
  }
  arg1 = (Fl_Roller *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Roller *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Roller_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Roller *arg1 = (Fl_Roller *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Roller_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Roller, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Roller_handle" "', argument " "1"" of type '" "Fl_Roller *""'"); 
  }
  arg1 = (Fl_Roller *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Roller_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Roller::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Roller(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Roller *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Roller", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Roller" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Roller" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Roller" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Roller" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Roller" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Roller *)new SwigDirector_Fl_Roller(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Roller *)new Fl_Roller(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Roller, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Roller_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Roller *arg1 = (Fl_Roller *) 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, "Fl_Roller_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Roller, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Roller_init_type" "', argument " "1"" of type '" "Fl_Roller *""'"); 
  }
  arg1 = (Fl_Roller *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Roller_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Roller_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Roller(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Roller *arg1 = (Fl_Roller *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Roller, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Roller" "', argument " "1"" of type '" "Fl_Roller *""'"); 
  }
  arg1 = (Fl_Roller *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Roller(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Roller *arg1 = (Fl_Roller *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Roller, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Roller" "', argument " "1"" of type '" "Fl_Roller *""'"); 
  }
  arg1 = (Fl_Roller *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Round_Clock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Round_Clock *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Round_Clock", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Round_Clock" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Round_Clock" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Round_Clock" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Round_Clock" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Round_Clock" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Round_Clock *)new SwigDirector_Fl_Round_Clock(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Round_Clock *)new Fl_Round_Clock(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Round_Clock, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Round_Clock_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Round_Clock *arg1 = (Fl_Round_Clock *) 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, "Fl_Round_Clock_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Round_Clock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Round_Clock_init_type" "', argument " "1"" of type '" "Fl_Round_Clock *""'"); 
  }
  arg1 = (Fl_Round_Clock *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Round_Clock_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Round_Clock_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Round_Clock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Round_Clock *arg1 = (Fl_Round_Clock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Round_Clock, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Round_Clock" "', argument " "1"" of type '" "Fl_Round_Clock *""'"); 
  }
  arg1 = (Fl_Round_Clock *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Round_Clock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Round_Clock *arg1 = (Fl_Round_Clock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Round_Clock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Round_Clock" "', argument " "1"" of type '" "Fl_Round_Clock *""'"); 
  }
  arg1 = (Fl_Round_Clock *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Round_Clock_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Round_Clock *arg1 = (Fl_Round_Clock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Round_Clock *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Round_Clock, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Round_Clock_draw" "', argument " "1"" of type '" "Fl_Round_Clock *""'"); 
  }
  arg1 = (Fl_Round_Clock *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Round_Clock *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Scroll_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Scroll *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scroll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scroll_draw" "', argument " "1"" of type '" "Fl_Scroll *""'"); 
  }
  arg1 = (Fl_Scroll *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Scroll *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Scroll_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scroll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scroll_resize" "', argument " "1"" of type '" "Fl_Scroll *""'"); 
  }
  arg1 = (Fl_Scroll *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Scroll_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Scroll_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Scroll_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Scroll_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Scroll::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Scroll_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scroll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scroll_handle" "', argument " "1"" of type '" "Fl_Scroll *""'"); 
  }
  arg1 = (Fl_Scroll *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Scroll_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Scroll::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Scroll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Scroll *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Scroll", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Scroll" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Scroll" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Scroll" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Scroll" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Scroll" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Scroll *)new SwigDirector_Fl_Scroll(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Scroll *)new Fl_Scroll(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Scroll, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Scroll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scroll, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Scroll" "', argument " "1"" of type '" "Fl_Scroll *""'"); 
  }
  arg1 = (Fl_Scroll *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_xposition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 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_Fl_Scroll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scroll_xposition" "', argument " "1"" of type '" "Fl_Scroll const *""'"); 
  }
  arg1 = (Fl_Scroll *)(argp1);
  {
    try {
      result = (int)((Fl_Scroll const *)arg1)->xposition(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_yposition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 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_Fl_Scroll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scroll_yposition" "', argument " "1"" of type '" "Fl_Scroll const *""'"); 
  }
  arg1 = (Fl_Scroll *)(argp1);
  {
    try {
      result = (int)((Fl_Scroll const *)arg1)->yposition(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_scroll_to(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 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, "Fl_Scroll_scroll_to", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scroll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scroll_scroll_to" "', argument " "1"" of type '" "Fl_Scroll *""'"); 
  }
  arg1 = (Fl_Scroll *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Scroll_scroll_to" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Scroll_scroll_to" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->scroll_to(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scroll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scroll_clear" "', argument " "1"" of type '" "Fl_Scroll *""'"); 
  }
  arg1 = (Fl_Scroll *)(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_delete_child(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Scroll_delete_child", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scroll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scroll_delete_child" "', argument " "1"" of type '" "Fl_Scroll *""'"); 
  }
  arg1 = (Fl_Scroll *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Scroll_delete_child" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Scroll::delete_child(arg2);
        } else {
          result = (int)(arg1)->delete_child(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_scrollbar_size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 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_Fl_Scroll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scroll_scrollbar_size" "', argument " "1"" of type '" "Fl_Scroll const *""'"); 
  }
  arg1 = (Fl_Scroll *)(argp1);
  {
    try {
      result = (int)((Fl_Scroll const *)arg1)->scrollbar_size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_scrollbar_size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 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_Fl_Scroll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scroll_scrollbar_size" "', argument " "1"" of type '" "Fl_Scroll *""'"); 
  }
  arg1 = (Fl_Scroll *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Scroll_scrollbar_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->scrollbar_size(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_scrollbar_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Scroll_scrollbar_size", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Scroll_scrollbar_size__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Scroll_scrollbar_size__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Scroll_scrollbar_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Scroll::scrollbar_size() const\n"
    "    Fl_Scroll::scrollbar_size(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 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, "Fl_Scroll_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scroll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scroll_init_type" "', argument " "1"" of type '" "Fl_Scroll *""'"); 
  }
  arg1 = (Fl_Scroll *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Scroll_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Scroll_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_getScrollbar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Scrollbar *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scroll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scroll_getScrollbar" "', argument " "1"" of type '" "Fl_Scroll *""'"); 
  }
  arg1 = (Fl_Scroll *)(argp1);
  {
    try {
      result = (Fl_Scrollbar *)Fl_Scroll_getScrollbar(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Scrollbar, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_getHScrollbar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Scrollbar *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scroll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scroll_getHScrollbar" "', argument " "1"" of type '" "Fl_Scroll *""'"); 
  }
  arg1 = (Fl_Scroll *)(argp1);
  {
    try {
      result = (Fl_Scrollbar *)Fl_Scroll_getHScrollbar(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Scrollbar, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Scroll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scroll, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Scroll" "', argument " "1"" of type '" "Fl_Scroll *""'"); 
  }
  arg1 = (Fl_Scroll *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Scheme_Choice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Scheme_Choice *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Scheme_Choice", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Scheme_Choice" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Scheme_Choice" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Scheme_Choice" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Scheme_Choice" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Scheme_Choice" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Scheme_Choice *)new SwigDirector_Fl_Scheme_Choice(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Scheme_Choice *)new Fl_Scheme_Choice(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Scheme_Choice, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scheme_Choice_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scheme_Choice *arg1 = (Fl_Scheme_Choice *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Scheme_Choice_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scheme_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scheme_Choice_handle" "', argument " "1"" of type '" "Fl_Scheme_Choice *""'"); 
  }
  arg1 = (Fl_Scheme_Choice *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Scheme_Choice_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Scheme_Choice::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scheme_Choice_init_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scheme_Choice *arg1 = (Fl_Scheme_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scheme_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scheme_Choice_init_value" "', argument " "1"" of type '" "Fl_Scheme_Choice *""'"); 
  }
  arg1 = (Fl_Scheme_Choice *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Scheme_Choice::init_value();
        } else {
          (arg1)->init_value();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scheme_Choice_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scheme_Choice *arg1 = (Fl_Scheme_Choice *) 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, "Fl_Scheme_Choice_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scheme_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scheme_Choice_init_type" "', argument " "1"" of type '" "Fl_Scheme_Choice *""'"); 
  }
  arg1 = (Fl_Scheme_Choice *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Scheme_Choice_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Scheme_Choice_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Scheme_Choice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scheme_Choice *arg1 = (Fl_Scheme_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scheme_Choice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Scheme_Choice" "', argument " "1"" of type '" "Fl_Scheme_Choice *""'"); 
  }
  arg1 = (Fl_Scheme_Choice *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Scheme_Choice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scheme_Choice *arg1 = (Fl_Scheme_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scheme_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Scheme_Choice" "', argument " "1"" of type '" "Fl_Scheme_Choice *""'"); 
  }
  arg1 = (Fl_Scheme_Choice *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scheme_Choice_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scheme_Choice *arg1 = (Fl_Scheme_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Scheme_Choice *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scheme_Choice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scheme_Choice_draw" "', argument " "1"" of type '" "Fl_Scheme_Choice *""'"); 
  }
  arg1 = (Fl_Scheme_Choice *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Scheme_Choice *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Scrollbar_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scrollbar *arg1 = (Fl_Scrollbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Scrollbar *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scrollbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scrollbar_draw" "', argument " "1"" of type '" "Fl_Scrollbar *""'"); 
  }
  arg1 = (Fl_Scrollbar *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Scrollbar *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Scrollbar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Scrollbar *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Scrollbar", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Scrollbar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Scrollbar" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Scrollbar" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Scrollbar" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Scrollbar" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Scrollbar *)new SwigDirector_Fl_Scrollbar(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Scrollbar *)new Fl_Scrollbar(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Scrollbar, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Scrollbar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scrollbar *arg1 = (Fl_Scrollbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scrollbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Scrollbar" "', argument " "1"" of type '" "Fl_Scrollbar *""'"); 
  }
  arg1 = (Fl_Scrollbar *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scrollbar_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scrollbar *arg1 = (Fl_Scrollbar *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Scrollbar_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scrollbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scrollbar_handle" "', argument " "1"" of type '" "Fl_Scrollbar *""'"); 
  }
  arg1 = (Fl_Scrollbar *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Scrollbar_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Scrollbar::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scrollbar_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Scrollbar *arg1 = (Fl_Scrollbar *) 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_Fl_Scrollbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scrollbar_value" "', argument " "1"" of type '" "Fl_Scrollbar const *""'"); 
  }
  arg1 = (Fl_Scrollbar *)(argp1);
  {
    try {
      result = (int)((Fl_Scrollbar const *)arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scrollbar_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Scrollbar *arg1 = (Fl_Scrollbar *) 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_Fl_Scrollbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scrollbar_value" "', argument " "1"" of type '" "Fl_Scrollbar *""'"); 
  }
  arg1 = (Fl_Scrollbar *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Scrollbar_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)(arg1)->value(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scrollbar_value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Scrollbar *arg1 = (Fl_Scrollbar *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scrollbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scrollbar_value" "', argument " "1"" of type '" "Fl_Scrollbar *""'"); 
  }
  arg1 = (Fl_Scrollbar *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Scrollbar_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Scrollbar_value" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Scrollbar_value" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Scrollbar_value" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      result = (int)(arg1)->value(arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scrollbar_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Scrollbar_value", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Scrollbar_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Scrollbar_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_Fl_Scrollbar_value__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Scrollbar_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Scrollbar::value() const\n"
    "    Fl_Scrollbar::value(int)\n"
    "    Fl_Scrollbar::value(int,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Scrollbar_linesize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Scrollbar *arg1 = (Fl_Scrollbar *) 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_Fl_Scrollbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scrollbar_linesize" "', argument " "1"" of type '" "Fl_Scrollbar const *""'"); 
  }
  arg1 = (Fl_Scrollbar *)(argp1);
  {
    try {
      result = (int)((Fl_Scrollbar const *)arg1)->linesize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scrollbar_linesize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Scrollbar *arg1 = (Fl_Scrollbar *) 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_Fl_Scrollbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scrollbar_linesize" "', argument " "1"" of type '" "Fl_Scrollbar *""'"); 
  }
  arg1 = (Fl_Scrollbar *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Scrollbar_linesize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->linesize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scrollbar_linesize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Scrollbar_linesize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Scrollbar_linesize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Scrollbar_linesize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Scrollbar_linesize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Scrollbar::linesize() const\n"
    "    Fl_Scrollbar::linesize(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Scrollbar_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scrollbar *arg1 = (Fl_Scrollbar *) 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, "Fl_Scrollbar_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scrollbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Scrollbar_init_type" "', argument " "1"" of type '" "Fl_Scrollbar *""'"); 
  }
  arg1 = (Fl_Scrollbar *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Scrollbar_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Scrollbar_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Scrollbar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scrollbar *arg1 = (Fl_Scrollbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Scrollbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Scrollbar" "', argument " "1"" of type '" "Fl_Scrollbar *""'"); 
  }
  arg1 = (Fl_Scrollbar *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Secret_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Secret_Input *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Secret_Input", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Secret_Input" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Secret_Input" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Secret_Input" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Secret_Input" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Secret_Input" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Secret_Input *)new SwigDirector_Fl_Secret_Input(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Secret_Input *)new Fl_Secret_Input(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Secret_Input, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Secret_Input_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Secret_Input *arg1 = (Fl_Secret_Input *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Secret_Input_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Secret_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Secret_Input_handle" "', argument " "1"" of type '" "Fl_Secret_Input *""'"); 
  }
  arg1 = (Fl_Secret_Input *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Secret_Input_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Secret_Input::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Secret_Input_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Secret_Input *arg1 = (Fl_Secret_Input *) 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, "Fl_Secret_Input_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Secret_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Secret_Input_init_type" "', argument " "1"" of type '" "Fl_Secret_Input *""'"); 
  }
  arg1 = (Fl_Secret_Input *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Secret_Input_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Secret_Input_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Secret_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Secret_Input *arg1 = (Fl_Secret_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Secret_Input, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Secret_Input" "', argument " "1"" of type '" "Fl_Secret_Input *""'"); 
  }
  arg1 = (Fl_Secret_Input *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Secret_Input(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Secret_Input *arg1 = (Fl_Secret_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Secret_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Secret_Input" "', argument " "1"" of type '" "Fl_Secret_Input *""'"); 
  }
  arg1 = (Fl_Secret_Input *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Secret_Input_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Secret_Input *arg1 = (Fl_Secret_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Secret_Input *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Secret_Input, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Secret_Input_draw" "', argument " "1"" of type '" "Fl_Secret_Input *""'"); 
  }
  arg1 = (Fl_Secret_Input *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Secret_Input *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Select_Browser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Select_Browser *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Select_Browser", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Select_Browser" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Select_Browser" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Select_Browser" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Select_Browser" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Select_Browser" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Select_Browser *)new SwigDirector_Fl_Select_Browser(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Select_Browser *)new Fl_Select_Browser(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Select_Browser, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 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, "Fl_Select_Browser_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Select_Browser_init_type" "', argument " "1"" of type '" "Fl_Select_Browser *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Select_Browser_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Select_Browser_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Select_Browser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Select_Browser" "', argument " "1"" of type '" "Fl_Select_Browser *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Select_Browser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Select_Browser" "', argument " "1"" of type '" "Fl_Select_Browser *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Select_Browser_draw" "', argument " "1"" of type '" "Fl_Select_Browser *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_first(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Select_Browser_item_first" "', argument " "1"" of type '" "Fl_Select_Browser const *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_first"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_first");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Select_Browser const *)darg)->item_firstSwigPublic();
        } else {
          result = (void *)((SwigDirector_Fl_Select_Browser const *)darg)->item_first();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Select_Browser_item_next", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Select_Browser_item_next" "', argument " "1"" of type '" "Fl_Select_Browser const *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(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 '" "Fl_Select_Browser_item_next" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_next"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_next");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Select_Browser const *)darg)->item_nextSwigPublic(arg2);
        } else {
          result = (void *)((SwigDirector_Fl_Select_Browser const *)darg)->item_next(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_prev(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Select_Browser_item_prev", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Select_Browser_item_prev" "', argument " "1"" of type '" "Fl_Select_Browser const *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(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 '" "Fl_Select_Browser_item_prev" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_prev"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_prev");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Select_Browser const *)darg)->item_prevSwigPublic(arg2);
        } else {
          result = (void *)((SwigDirector_Fl_Select_Browser const *)darg)->item_prev(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_last(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Select_Browser_item_last" "', argument " "1"" of type '" "Fl_Select_Browser const *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_last"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_last");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Select_Browser const *)darg)->item_lastSwigPublic();
        } else {
          result = (void *)((SwigDirector_Fl_Select_Browser const *)darg)->item_last();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Select_Browser_item_height", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Select_Browser_item_height" "', argument " "1"" of type '" "Fl_Select_Browser const *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(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 '" "Fl_Select_Browser_item_height" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Select_Browser const *)darg)->item_heightSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Select_Browser const *)darg)->item_height(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_width(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Select_Browser_item_width", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Select_Browser_item_width" "', argument " "1"" of type '" "Fl_Select_Browser const *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(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 '" "Fl_Select_Browser_item_width" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_width"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_width");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Select_Browser const *)darg)->item_widthSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Select_Browser const *)darg)->item_width(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_quick_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Select_Browser_item_quick_height", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Select_Browser_item_quick_height" "', argument " "1"" of type '" "Fl_Select_Browser const *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(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 '" "Fl_Select_Browser_item_quick_height" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_quick_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_quick_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Select_Browser const *)darg)->item_quick_heightSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Select_Browser const *)darg)->item_quick_height(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Select_Browser_item_draw", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Select_Browser_item_draw" "', argument " "1"" of type '" "Fl_Select_Browser const *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(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 '" "Fl_Select_Browser_item_draw" "', 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 '" "Fl_Select_Browser_item_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Select_Browser_item_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Select_Browser_item_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Select_Browser_item_draw" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = (int)(val6);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    {
      try {
        if (upcall) {
          ((SwigDirector_Fl_Select_Browser const *)darg)->item_drawSwigPublic(arg2,arg3,arg4,arg5,arg6);
        } else {
          ((SwigDirector_Fl_Select_Browser const *)darg)->item_draw(arg2,arg3,arg4,arg5,arg6);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_text(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Select_Browser_item_text", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Select_Browser_item_text" "', argument " "1"" of type '" "Fl_Select_Browser const *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(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 '" "Fl_Select_Browser_item_text" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_text"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_text");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (char *)((SwigDirector_Fl_Select_Browser const *)darg)->item_textSwigPublic(arg2);
        } else {
          result = (char *)((SwigDirector_Fl_Select_Browser const *)darg)->item_text(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (director) {
    director->swig_release_ownership(SWIG_as_voidptr(result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Select_Browser_item_swap", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Select_Browser_item_swap" "', argument " "1"" of type '" "Fl_Select_Browser *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(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 '" "Fl_Select_Browser_item_swap" "', argument " "2"" of type '" "void *""'"); 
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Select_Browser_item_swap" "', argument " "3"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_swap"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_swap");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->item_swapSwigPublic(arg2,arg3);
        } else {
          (darg)->item_swap(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_at(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Select_Browser_item_at", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Select_Browser_item_at" "', argument " "1"" of type '" "Fl_Select_Browser const *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Select_Browser_item_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_at"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_at");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (void *)((SwigDirector_Fl_Select_Browser const *)darg)->item_atSwigPublic(arg2);
        } else {
          result = (void *)((SwigDirector_Fl_Select_Browser const *)darg)->item_at(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_full_width(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Select_Browser_full_width" "', argument " "1"" of type '" "Fl_Select_Browser const *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("full_width"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member full_width");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Select_Browser const *)darg)->full_widthSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Select_Browser const *)darg)->full_width();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_full_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Select_Browser_full_height" "', argument " "1"" of type '" "Fl_Select_Browser const *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("full_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member full_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Select_Browser const *)darg)->full_heightSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Select_Browser const *)darg)->full_height();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_incr_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Select_Browser_incr_height" "', argument " "1"" of type '" "Fl_Select_Browser const *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("incr_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member incr_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Select_Browser const *)darg)->incr_heightSwigPublic();
        } else {
          result = (int)((SwigDirector_Fl_Select_Browser const *)darg)->incr_height();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_select(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Select_Browser_item_select", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Select_Browser_item_select" "', argument " "1"" of type '" "Fl_Select_Browser *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(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 '" "Fl_Select_Browser_item_select" "', 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 '" "Fl_Select_Browser_item_select" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_select"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_select");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->item_selectSwigPublic(arg2,arg3);
        } else {
          (darg)->item_select(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_selected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Select_Browser_item_selected", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Select_Browser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Select_Browser_item_selected" "', argument " "1"" of type '" "Fl_Select_Browser const *""'"); 
  }
  arg1 = (Fl_Select_Browser *)(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 '" "Fl_Select_Browser_item_selected" "', argument " "2"" of type '" "void *""'"); 
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("item_selected"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member item_selected");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)((SwigDirector_Fl_Select_Browser const *)darg)->item_selectedSwigPublic(arg2);
        } else {
          result = (int)((SwigDirector_Fl_Select_Browser const *)darg)->item_selected(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Shared_Image__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  Fl_Shared_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = swig_obj[0];
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Shared_Image *)new SwigDirector_Fl_Shared_Image(arg1); 
      } else {
        SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
        SWIG_fail;
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Shared_Image, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Shared_Image__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  Fl_Image *arg3 = (Fl_Image *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Fl_Shared_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_Shared_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Fl_Image, 0 |  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fl_Shared_Image" "', argument " "3"" of type '" "Fl_Image *""'"); 
    }
    arg3 = (Fl_Image *)(argp3);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Shared_Image *)new SwigDirector_Fl_Shared_Image(arg1,(char const *)arg2,arg3); 
      } else {
        SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
        SWIG_fail;
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Shared_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Shared_Image(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_Shared_Image", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_Fl_Shared_Image__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 2) && (argc <= 3)) {
    PyObject *retobj = _wrap_new_Fl_Shared_Image__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_Shared_Image'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Shared_Image::Fl_Shared_Image()\n"
    "    Fl_Shared_Image::Fl_Shared_Image(PyObject *,char const *,Fl_Image *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 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_Fl_Shared_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shared_Image_name" "', argument " "1"" of type '" "Fl_Shared_Image *""'"); 
  }
  arg1 = (Fl_Shared_Image *)(argp1);
  {
    try {
      result = (char *)(arg1)->name(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_refcount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 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_Fl_Shared_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shared_Image_refcount" "', argument " "1"" of type '" "Fl_Shared_Image *""'"); 
  }
  arg1 = (Fl_Shared_Image *)(argp1);
  {
    try {
      result = (int)(arg1)->refcount(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_original(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 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_Fl_Shared_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shared_Image_original" "', argument " "1"" of type '" "Fl_Shared_Image *""'"); 
  }
  arg1 = (Fl_Shared_Image *)(argp1);
  {
    try {
      result = (int)(arg1)->original(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_release(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Shared_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shared_Image_release" "', argument " "1"" of type '" "Fl_Shared_Image *""'"); 
  }
  arg1 = (Fl_Shared_Image *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Shared_Image::release();
        } else {
          (arg1)->release();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_reload(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Shared_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shared_Image_reload" "', argument " "1"" of type '" "Fl_Shared_Image *""'"); 
  }
  arg1 = (Fl_Shared_Image *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Shared_Image::reload();
        } else {
          (arg1)->reload();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_as_shared_image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Shared_Image *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Shared_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shared_Image_as_shared_image" "', argument " "1"" of type '" "Fl_Shared_Image *""'"); 
  }
  arg1 = (Fl_Shared_Image *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Shared_Image *)(arg1)->Fl_Shared_Image::as_shared_image();
        } else {
          result = (Fl_Shared_Image *)(arg1)->as_shared_image();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Shared_Image, 0 |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_copy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Shared_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shared_Image_copy" "', argument " "1"" of type '" "Fl_Shared_Image const *""'"); 
  }
  arg1 = (Fl_Shared_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Shared_Image_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Shared_Image_copy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Image *)((Fl_Shared_Image const *)arg1)->Fl_Shared_Image::copy(arg2,arg3);
        } else {
          result = (Fl_Image *)((Fl_Shared_Image const *)arg1)->copy(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, SWIG_POINTER_OWN |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_copy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Shared_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shared_Image_copy" "', argument " "1"" of type '" "Fl_Shared_Image const *""'"); 
  }
  arg1 = (Fl_Shared_Image *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Shared_Image const *)arg1)->copy(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_copy__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Shared_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shared_Image_copy" "', argument " "1"" of type '" "Fl_Shared_Image *""'"); 
  }
  arg1 = (Fl_Shared_Image *)(argp1);
  {
    try {
      result = (Fl_Image *)(arg1)->copy(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_copy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Shared_Image_copy", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Shared_Image_copy__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Shared_Image_copy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Shared_Image_copy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Shared_Image_copy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Shared_Image::copy(int,int) const\n"
    "    Fl_Shared_Image::copy() const\n"
    "    Fl_Shared_Image::copy()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_color_average(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  Fl_Color arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Shared_Image_color_average", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Shared_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shared_Image_color_average" "', argument " "1"" of type '" "Fl_Shared_Image *""'"); 
  }
  arg1 = (Fl_Shared_Image *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Shared_Image_color_average" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Shared_Image_color_average" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = (float)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Shared_Image::color_average(arg2,arg3);
        } else {
          (arg1)->color_average(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_desaturate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Shared_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shared_Image_desaturate" "', argument " "1"" of type '" "Fl_Shared_Image *""'"); 
  }
  arg1 = (Fl_Shared_Image *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Shared_Image::desaturate();
        } else {
          (arg1)->desaturate();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_draw__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 = (int) 0 ;
  int arg7 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Shared_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shared_Image_draw" "', argument " "1"" of type '" "Fl_Shared_Image *""'"); 
  }
  arg1 = (Fl_Shared_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Shared_Image_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Shared_Image_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Shared_Image_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Shared_Image_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Shared_Image_draw" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Shared_Image_draw" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Shared_Image::draw(arg2,arg3,arg4,arg5,arg6,arg7);
        } else {
          (arg1)->draw(arg2,arg3,arg4,arg5,arg6,arg7);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_draw__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 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_Fl_Shared_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shared_Image_draw" "', argument " "1"" of type '" "Fl_Shared_Image *""'"); 
  }
  arg1 = (Fl_Shared_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Shared_Image_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Shared_Image_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->draw(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_draw(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Shared_Image_draw", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Shared_Image_draw__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 5) && (argc <= 7)) {
    PyObject *retobj = _wrap_Fl_Shared_Image_draw__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Shared_Image_draw'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Shared_Image::draw(int,int,int,int,int,int)\n"
    "    Fl_Shared_Image::draw(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_uncache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Shared_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shared_Image_uncache" "', argument " "1"" of type '" "Fl_Shared_Image *""'"); 
  }
  arg1 = (Fl_Shared_Image *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Shared_Image::uncache();
        } else {
          (arg1)->uncache();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 = (int) 0 ;
  int arg3 = (int) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  Fl_Shared_Image *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Shared_Image_find", 1, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shared_Image_find" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Shared_Image_find" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Shared_Image_find" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (Fl_Shared_Image *)Fl_Shared_Image::find((char const *)arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Shared_Image, 0 |  0 );
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_get__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 = (int) 0 ;
  int arg3 = (int) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Swig::Director *director = 0;
  Fl_Shared_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (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 '" "Fl_Shared_Image_get" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Shared_Image_get" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Shared_Image_get" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (Fl_Shared_Image *)Fl_Shared_Image::get((char const *)arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Shared_Image, 0 |  0 );
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_get__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  int arg2 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Swig::Director *director = 0;
  Fl_Shared_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_RGB_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shared_Image_get" "', argument " "1"" of type '" "Fl_RGB_Image *""'"); 
  }
  arg1 = (Fl_RGB_Image *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Shared_Image_get" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      result = (Fl_Shared_Image *)Fl_Shared_Image::get(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Shared_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Shared_Image_get", 0, 3, argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Fl_RGB_Image, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_Fl_Shared_Image_get__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if ((argc >= 1) && (argc <= 3)) {
    PyObject *retobj = _wrap_Fl_Shared_Image_get__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Shared_Image_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Shared_Image::get(char const *,int,int)\n"
    "    Fl_Shared_Image::get(Fl_RGB_Image *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_images(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image **result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Shared_Image_images", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Shared_Image **)Fl_Shared_Image::images(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_Fl_Shared_Image, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_num_images(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Shared_Image_num_images", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)Fl_Shared_Image::num_images(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_add_handler(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Handler arg1 = (Fl_Shared_Handler) 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_Image);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Shared_Image_add_handler" "', argument " "1"" of type '" "Fl_Shared_Handler""'"); 
    }
  }
  {
    try {
      Fl_Shared_Image::add_handler(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_remove_handler(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Handler arg1 = (Fl_Shared_Handler) 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_Image);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Shared_Image_remove_handler" "', argument " "1"" of type '" "Fl_Shared_Handler""'"); 
    }
  }
  {
    try {
      Fl_Shared_Image::remove_handler(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Shared_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shared_Image_image" "', argument " "1"" of type '" "Fl_Shared_Image const *""'"); 
  }
  arg1 = (Fl_Shared_Image *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Shared_Image const *)arg1)->image(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Shared_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Shared_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Shared_Image" "', argument " "1"" of type '" "Fl_Shared_Image *""'"); 
  }
  arg1 = (Fl_Shared_Image *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_fl_register_images(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_register_images", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_register_images(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Spinner *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_draw" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Spinner *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Spinner(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Spinner *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Spinner", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Spinner" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Spinner" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Spinner" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Spinner" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Spinner" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Spinner *)new SwigDirector_Fl_Spinner(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Spinner *)new Fl_Spinner(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Spinner, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Spinner_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_handle" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Spinner::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Spinner_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_resize" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Spinner_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Spinner_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Spinner_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Spinner::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_format__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_format" "', argument " "1"" of type '" "Fl_Spinner const *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  {
    try {
      result = (char *)((Fl_Spinner const *)arg1)->format(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_format__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_format" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Spinner_format" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->format((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_format(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Spinner_format", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Spinner_format__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Spinner_format__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Spinner_format'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Spinner::format() const\n"
    "    Fl_Spinner::format(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_range(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Spinner_range", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_range" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_range" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Spinner_range" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = (double)(val3);
  {
    try {
      (arg1)->range(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_step__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 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_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_step" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_step" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      (arg1)->step(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_step__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 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_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_step" "', argument " "1"" of type '" "Fl_Spinner const *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  {
    try {
      result = (double)((Fl_Spinner const *)arg1)->step(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_step(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Spinner_step", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Spinner_step__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Spinner_step__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Spinner_step'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Spinner::step(double)\n"
    "    Fl_Spinner::step() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_wrap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 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_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_wrap" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_wrap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->wrap(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_wrap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 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_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_wrap" "', argument " "1"" of type '" "Fl_Spinner const *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  {
    try {
      result = (int)((Fl_Spinner const *)arg1)->wrap(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_wrap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Spinner_wrap", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Spinner_wrap__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Spinner_wrap__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Spinner_wrap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Spinner::wrap(int)\n"
    "    Fl_Spinner::wrap() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_textcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_textcolor" "', argument " "1"" of type '" "Fl_Spinner const *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Spinner const *)arg1)->textcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_textcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_textcolor" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->textcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_textcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Spinner_textcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Spinner_textcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Spinner_textcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Spinner_textcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Spinner::textcolor() const\n"
    "    Fl_Spinner::textcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_textfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_textfont" "', argument " "1"" of type '" "Fl_Spinner const *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Spinner const *)arg1)->textfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_textfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  Fl_Font 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_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_textfont" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->textfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_textfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Spinner_textfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Spinner_textfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Spinner_textfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Spinner_textfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Spinner::textfont() const\n"
    "    Fl_Spinner::textfont(Fl_Font)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_textsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_textsize" "', argument " "1"" of type '" "Fl_Spinner const *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Spinner const *)arg1)->textsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_textsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  Fl_Fontsize 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_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_textsize" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->textsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_textsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Spinner_textsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Spinner_textsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Spinner_textsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Spinner_textsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Spinner::textsize() const\n"
    "    Fl_Spinner::textsize(Fl_Fontsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_type__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_type" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_type" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  {
    try {
      (arg1)->type(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_type__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_type" "', argument " "1"" of type '" "Fl_Spinner const *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  {
    try {
      result = (uchar)((Fl_Spinner const *)arg1)->type(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_type(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Spinner_type", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Spinner_type__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Spinner_type__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Spinner_type'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Spinner::type(uchar)\n"
    "    Fl_Spinner::type() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 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_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_value" "', argument " "1"" of type '" "Fl_Spinner const *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  {
    try {
      result = (double)((Fl_Spinner const *)arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 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_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_value" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_value" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      (arg1)->value(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Spinner_value", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Spinner_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Spinner_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Spinner_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Spinner::value() const\n"
    "    Fl_Spinner::value(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_color" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->color(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_color" "', argument " "1"" of type '" "Fl_Spinner const *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Spinner const *)arg1)->color(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Spinner_color", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Spinner_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Spinner_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Spinner_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Spinner::color(Fl_Color)\n"
    "    Fl_Spinner::color() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_selection_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_selection_color" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_selection_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->selection_color(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_selection_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_selection_color" "', argument " "1"" of type '" "Fl_Spinner const *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Spinner const *)arg1)->selection_color(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_selection_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Spinner_selection_color", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Spinner_selection_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Spinner_selection_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Spinner_selection_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Spinner::selection_color(Fl_Color)\n"
    "    Fl_Spinner::selection_color() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_maximum_size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 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_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_maximum_size" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_maximum_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->maximum_size(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_maximum_size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 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_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_maximum_size" "', argument " "1"" of type '" "Fl_Spinner const *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  {
    try {
      result = (int)((Fl_Spinner const *)arg1)->maximum_size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_maximum_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Spinner_maximum_size", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Spinner_maximum_size__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Spinner_maximum_size__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Spinner_maximum_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Spinner::maximum_size(int)\n"
    "    Fl_Spinner::maximum_size() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 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, "Fl_Spinner_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_init_type" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Spinner_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Spinner_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_minimum__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 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_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_minimum" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_minimum" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      Fl_Spinner_min__SWIG_0(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_minimum__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 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_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_minimum" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  {
    try {
      result = (double)Fl_Spinner_min__SWIG_1(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_minimum(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Spinner_minimum", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Spinner_minimum__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Spinner_minimum__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Spinner_minimum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Spinner::min(double)\n"
    "    Fl_Spinner::min()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_maximum__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 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_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_maximum" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_maximum" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      Fl_Spinner_max__SWIG_0(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_maximum__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 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_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_maximum" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  {
    try {
      result = (double)Fl_Spinner_max__SWIG_1(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_maximum(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Spinner_maximum", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Spinner_maximum__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Spinner_maximum__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Spinner_maximum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Spinner::max(double)\n"
    "    Fl_Spinner::max()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Spinner(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Spinner, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Spinner" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Spinner(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Spinner" "', argument " "1"" of type '" "Fl_Spinner *""'"); 
  }
  arg1 = (Fl_Spinner *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_fl_show_colormap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Color result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_show_colormap" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  {
    try {
      result = (Fl_Color)fl_show_colormap(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Simple_Counter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Simple_Counter *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Simple_Counter", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Simple_Counter" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Simple_Counter" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Simple_Counter" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Simple_Counter" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Simple_Counter" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Simple_Counter *)new SwigDirector_Fl_Simple_Counter(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Simple_Counter *)new Fl_Simple_Counter(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Simple_Counter, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Simple_Counter_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Simple_Counter *arg1 = (Fl_Simple_Counter *) 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, "Fl_Simple_Counter_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Simple_Counter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Simple_Counter_init_type" "', argument " "1"" of type '" "Fl_Simple_Counter *""'"); 
  }
  arg1 = (Fl_Simple_Counter *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Simple_Counter_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Simple_Counter_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Simple_Counter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Simple_Counter *arg1 = (Fl_Simple_Counter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Simple_Counter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Simple_Counter" "', argument " "1"" of type '" "Fl_Simple_Counter *""'"); 
  }
  arg1 = (Fl_Simple_Counter *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Simple_Counter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Simple_Counter *arg1 = (Fl_Simple_Counter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Simple_Counter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Simple_Counter" "', argument " "1"" of type '" "Fl_Simple_Counter *""'"); 
  }
  arg1 = (Fl_Simple_Counter *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Simple_Counter_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Simple_Counter *arg1 = (Fl_Simple_Counter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Simple_Counter *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Simple_Counter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Simple_Counter_draw" "', argument " "1"" of type '" "Fl_Simple_Counter *""'"); 
  }
  arg1 = (Fl_Simple_Counter *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Simple_Counter *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar *arg1 = (Fl_Sys_Menu_Bar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Sys_Menu_Bar *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Sys_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Sys_Menu_Bar_draw" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Sys_Menu_Bar *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Sys_Menu_Bar *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Sys_Menu_Bar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Sys_Menu_Bar *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Sys_Menu_Bar", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Sys_Menu_Bar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Sys_Menu_Bar" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Sys_Menu_Bar" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Sys_Menu_Bar" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Sys_Menu_Bar" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Sys_Menu_Bar *)new SwigDirector_Fl_Sys_Menu_Bar(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Sys_Menu_Bar *)new Fl_Sys_Menu_Bar(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Sys_Menu_Bar, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Sys_Menu_Bar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar *arg1 = (Fl_Sys_Menu_Bar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Sys_Menu_Bar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Sys_Menu_Bar" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Sys_Menu_Bar *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_menu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar *arg1 = (Fl_Sys_Menu_Bar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Menu_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Sys_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Sys_Menu_Bar_menu" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar const *""'"); 
  }
  arg1 = (Fl_Sys_Menu_Bar *)(argp1);
  {
    try {
      result = (Fl_Menu_Item *)((Fl_Sys_Menu_Bar const *)arg1)->menu(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_update(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar *arg1 = (Fl_Sys_Menu_Bar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Sys_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Sys_Menu_Bar_update" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Sys_Menu_Bar *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Sys_Menu_Bar::update();
        } else {
          (arg1)->update();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_play_menu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar *arg1 = (Fl_Sys_Menu_Bar *) 0 ;
  Fl_Menu_Item *arg2 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Sys_Menu_Bar_play_menu", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Sys_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Sys_Menu_Bar_play_menu" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Sys_Menu_Bar *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Sys_Menu_Bar_play_menu" "', argument " "2"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg2 = (Fl_Menu_Item *)(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Sys_Menu_Bar::play_menu((Fl_Menu_Item const *)arg2);
        } else {
          (arg1)->play_menu((Fl_Menu_Item const *)arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_add__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar *arg1 = (Fl_Sys_Menu_Bar *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  Fl_Callback *arg4 = (Fl_Callback *) 0 ;
  void *arg5 = (void *) 0 ;
  int arg6 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res5 ;
  int val6 ;
  int ecode6 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Sys_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Sys_Menu_Bar_add" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Sys_Menu_Bar *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Sys_Menu_Bar_add" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Sys_Menu_Bar_add" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[3], (void**)(&arg4), SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Sys_Menu_Bar_add" "', argument " "4"" of type '" "Fl_Callback *""'"); 
    }
  }
  if (swig_obj[4]) {
    res5 = SWIG_ConvertPtr(swig_obj[4],SWIG_as_voidptrptr(&arg5), 0, 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Fl_Sys_Menu_Bar_add" "', argument " "5"" of type '" "void *""'"); 
    }
  }
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Sys_Menu_Bar_add" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  {
    try {
      result = (int)(arg1)->add((char const *)arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_add__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar *arg1 = (Fl_Sys_Menu_Bar *) 0 ;
  char *arg2 = (char *) 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_Fl_Sys_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Sys_Menu_Bar_add" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Sys_Menu_Bar *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Sys_Menu_Bar_add" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)(arg1)->add((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Sys_Menu_Bar_add", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Sys_Menu_Bar_add__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 4) && (argc <= 6)) {
    PyObject *retobj = _wrap_Fl_Sys_Menu_Bar_add__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Sys_Menu_Bar_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Sys_Menu_Bar::add(char const *,int,Fl_Callback *,void *,int)\n"
    "    Fl_Sys_Menu_Bar::add(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar *arg1 = (Fl_Sys_Menu_Bar *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  Fl_Callback *arg5 = (Fl_Callback *) 0 ;
  void *arg6 = (void *) 0 ;
  int arg7 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int res6 ;
  int val7 ;
  int ecode7 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Sys_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Sys_Menu_Bar_insert" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Sys_Menu_Bar *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Sys_Menu_Bar_insert" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Sys_Menu_Bar_insert" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Sys_Menu_Bar_insert" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[4], (void**)(&arg5), SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Sys_Menu_Bar_insert" "', argument " "5"" of type '" "Fl_Callback *""'"); 
    }
  }
  if (swig_obj[5]) {
    res6 = SWIG_ConvertPtr(swig_obj[5],SWIG_as_voidptrptr(&arg6), 0, 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Fl_Sys_Menu_Bar_insert" "', argument " "6"" of type '" "void *""'"); 
    }
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Sys_Menu_Bar_insert" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  {
    try {
      result = (int)(arg1)->insert(arg2,(char const *)arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar *arg1 = (Fl_Sys_Menu_Bar *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  Fl_Callback *arg5 = (Fl_Callback *) 0 ;
  void *arg6 = (void *) 0 ;
  int arg7 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int res6 ;
  int val7 ;
  int ecode7 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Sys_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Sys_Menu_Bar_insert" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Sys_Menu_Bar *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Sys_Menu_Bar_insert" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Sys_Menu_Bar_insert" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Sys_Menu_Bar_insert" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = (char *)(buf4);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[4], (void**)(&arg5), SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Sys_Menu_Bar_insert" "', argument " "5"" of type '" "Fl_Callback *""'"); 
    }
  }
  if (swig_obj[5]) {
    res6 = SWIG_ConvertPtr(swig_obj[5],SWIG_as_voidptrptr(&arg6), 0, 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Fl_Sys_Menu_Bar_insert" "', argument " "6"" of type '" "void *""'"); 
    }
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Sys_Menu_Bar_insert" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  {
    try {
      result = (int)(arg1)->insert(arg2,(char const *)arg3,(char const *)arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Sys_Menu_Bar_insert", 0, 7, argv))) SWIG_fail;
  --argc;
  if ((argc >= 5) && (argc <= 7)) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[3], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_Fl_Sys_Menu_Bar_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if ((argc >= 5) && (argc <= 7)) {
    PyObject *retobj = _wrap_Fl_Sys_Menu_Bar_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Sys_Menu_Bar_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Sys_Menu_Bar::insert(int,char const *,int,Fl_Callback *,void *,int)\n"
    "    Fl_Sys_Menu_Bar::insert(int,char const *,char const *,Fl_Callback *,void *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar *arg1 = (Fl_Sys_Menu_Bar *) 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, "Fl_Sys_Menu_Bar_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Sys_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Sys_Menu_Bar_remove" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Sys_Menu_Bar *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Sys_Menu_Bar_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->remove(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_replace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar *arg1 = (Fl_Sys_Menu_Bar *) 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] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Sys_Menu_Bar_replace", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Sys_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Sys_Menu_Bar_replace" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Sys_Menu_Bar *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Sys_Menu_Bar_replace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Sys_Menu_Bar_replace" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      (arg1)->replace(arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar *arg1 = (Fl_Sys_Menu_Bar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Sys_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Sys_Menu_Bar_clear" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Sys_Menu_Bar *)(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_clear_submenu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar *arg1 = (Fl_Sys_Menu_Bar *) 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, "Fl_Sys_Menu_Bar_clear_submenu", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Sys_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Sys_Menu_Bar_clear_submenu" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Sys_Menu_Bar *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Sys_Menu_Bar_clear_submenu" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)(arg1)->clear_submenu(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_mode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar *arg1 = (Fl_Sys_Menu_Bar *) 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_Fl_Sys_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Sys_Menu_Bar_mode" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Sys_Menu_Bar *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Sys_Menu_Bar_mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Sys_Menu_Bar_mode" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->mode(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_mode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar *arg1 = (Fl_Sys_Menu_Bar *) 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_Fl_Sys_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Sys_Menu_Bar_mode" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar const *""'"); 
  }
  arg1 = (Fl_Sys_Menu_Bar *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Sys_Menu_Bar_mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Sys_Menu_Bar const *)arg1)->mode(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_mode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Sys_Menu_Bar_mode", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Sys_Menu_Bar_mode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Sys_Menu_Bar_mode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Sys_Menu_Bar_mode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Sys_Menu_Bar::mode(int,int)\n"
    "    Fl_Sys_Menu_Bar::mode(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_shortcut(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar *arg1 = (Fl_Sys_Menu_Bar *) 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, "Fl_Sys_Menu_Bar_shortcut", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Sys_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Sys_Menu_Bar_shortcut" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Sys_Menu_Bar *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Sys_Menu_Bar_shortcut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Sys_Menu_Bar_shortcut" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->shortcut(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_setonly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar *arg1 = (Fl_Sys_Menu_Bar *) 0 ;
  Fl_Menu_Item *arg2 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Sys_Menu_Bar_setonly", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Sys_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Sys_Menu_Bar_setonly" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Sys_Menu_Bar *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Sys_Menu_Bar_setonly" "', argument " "2"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg2 = (Fl_Menu_Item *)(argp2);
  {
    try {
      (arg1)->setonly(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_about(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Callback *arg1 = (Fl_Callback *) 0 ;
  void *arg2 = (void *) 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Sys_Menu_Bar_about", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_p_Fl_Widget_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Sys_Menu_Bar_about" "', argument " "1"" of type '" "Fl_Callback *""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Sys_Menu_Bar_about" "', argument " "2"" of type '" "void *""'"); 
  }
  {
    try {
      Fl_Sys_Menu_Bar::about(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_window_menu_style__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar::window_menu_style_enum result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Fl_Sys_Menu_Bar::window_menu_style_enum)Fl_Sys_Menu_Bar::window_menu_style(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_window_menu_style__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar::window_menu_style_enum arg1 ;
  int val1 ;
  int ecode1 = 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 '" "Fl_Sys_Menu_Bar_window_menu_style" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar::window_menu_style_enum""'");
  } 
  arg1 = (Fl_Sys_Menu_Bar::window_menu_style_enum)(val1);
  {
    try {
      Fl_Sys_Menu_Bar::window_menu_style(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_window_menu_style(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Sys_Menu_Bar_window_menu_style", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_Fl_Sys_Menu_Bar_window_menu_style__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Sys_Menu_Bar_window_menu_style__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Sys_Menu_Bar_window_menu_style'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Sys_Menu_Bar::window_menu_style()\n"
    "    Fl_Sys_Menu_Bar::window_menu_style(Fl_Sys_Menu_Bar::window_menu_style_enum)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_create_window_menu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Sys_Menu_Bar_create_window_menu", 0, 0, 0)) SWIG_fail;
  {
    try {
      Fl_Sys_Menu_Bar::create_window_menu(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Sys_Menu_Bar_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar *arg1 = (Fl_Sys_Menu_Bar *) 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, "Fl_Sys_Menu_Bar_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Sys_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Sys_Menu_Bar_init_type" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Sys_Menu_Bar *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Sys_Menu_Bar_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Sys_Menu_Bar_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Sys_Menu_Bar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Sys_Menu_Bar *arg1 = (Fl_Sys_Menu_Bar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Sys_Menu_Bar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Sys_Menu_Bar" "', argument " "1"" of type '" "Fl_Sys_Menu_Bar *""'"); 
  }
  arg1 = (Fl_Sys_Menu_Bar *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Table_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Table *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Table_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_handle" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("handle"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member handle");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Table *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)(darg)->handleSwigPublic(arg2);
        } else {
          result = (int)(darg)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_draw_cell(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  Fl_Table::TableContext arg2 ;
  int arg3 = (int) 0 ;
  int arg4 = (int) 0 ;
  int arg5 = (int) 0 ;
  int arg6 = (int) 0 ;
  int arg7 = (int) 0 ;
  int arg8 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject *swig_obj[8] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Table *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Table_draw_cell", 2, 8, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_draw_cell" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_draw_cell" "', argument " "2"" of type '" "Fl_Table::TableContext""'");
  } 
  arg2 = (Fl_Table::TableContext)(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_draw_cell" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Table_draw_cell" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Table_draw_cell" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = (int)(val5);
  }
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Table_draw_cell" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Table_draw_cell" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  if (swig_obj[7]) {
    ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Fl_Table_draw_cell" "', argument " "8"" of type '" "int""'");
    } 
    arg8 = (int)(val8);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw_cell"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw_cell");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Table *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->draw_cellSwigPublic(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
        } else {
          (darg)->draw_cell(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Table *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_draw" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Table *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Table(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Table *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Table", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Table" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Table" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Table" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Table" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Table" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Table *)new SwigDirector_Fl_Table(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Table *)new Fl_Table(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Table, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Table(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Table" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_clear" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Table::clear();
        } else {
          (arg1)->clear();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_table_box__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  Fl_Boxtype 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_table_box" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_table_box" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = (Fl_Boxtype)(val2);
  {
    try {
      (arg1)->table_box(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_table_box__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Boxtype result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_table_box" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (Fl_Boxtype)(arg1)->table_box(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_table_box(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_table_box", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_table_box__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_table_box__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_table_box'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::table_box(Fl_Boxtype)\n"
    "    Fl_Table::table_box()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_rows__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_rows" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_rows" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Table::rows(arg2);
        } else {
          (arg1)->rows(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_rows__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_rows" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (int)(arg1)->rows(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_rows(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_rows", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_rows__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_rows__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_rows'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::rows(int)\n"
    "    Fl_Table::rows()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_cols__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_cols" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_cols" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Table::cols(arg2);
        } else {
          (arg1)->cols(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_cols__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_cols" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (int)(arg1)->cols(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_cols(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_cols", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_cols__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_cols__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_cols'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::cols(int)\n"
    "    Fl_Table::cols()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_visible_cells(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  int temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_visible_cells" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      (arg1)->visible_cells(*arg2,*arg3,*arg4,*arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_is_interactive_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_is_interactive_resize" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (int)(arg1)->is_interactive_resize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_row_resize" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (int)(arg1)->row_resize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_row_resize" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_row_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->row_resize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_row_resize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_row_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_row_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_row_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::row_resize()\n"
    "    Fl_Table::row_resize(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_col_resize" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (int)(arg1)->col_resize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_col_resize" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_col_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->col_resize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_col_resize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_col_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_col_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_col_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::col_resize()\n"
    "    Fl_Table::col_resize(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_resize_min__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_col_resize_min" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (int)(arg1)->col_resize_min(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_resize_min__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_col_resize_min" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_col_resize_min" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->col_resize_min(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_resize_min(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_col_resize_min", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_col_resize_min__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_col_resize_min__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_col_resize_min'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::col_resize_min()\n"
    "    Fl_Table::col_resize_min(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_resize_min__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_row_resize_min" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (int)(arg1)->row_resize_min(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_resize_min__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_row_resize_min" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_row_resize_min" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->row_resize_min(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_resize_min(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_row_resize_min", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_row_resize_min__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_row_resize_min__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_row_resize_min'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::row_resize_min()\n"
    "    Fl_Table::row_resize_min(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_header__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_row_header" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (int)(arg1)->row_header(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_header__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_row_header" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_row_header" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->row_header(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_header(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_row_header", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_row_header__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_row_header__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_row_header'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::row_header()\n"
    "    Fl_Table::row_header(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_header__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_col_header" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (int)(arg1)->col_header(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_header__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_col_header" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_col_header" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->col_header(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_header(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_col_header", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_col_header__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_col_header__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_col_header'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::col_header()\n"
    "    Fl_Table::col_header(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_header_height__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_col_header_height" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_col_header_height" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->col_header_height(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_header_height__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_col_header_height" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (int)(arg1)->col_header_height(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_header_height(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_col_header_height", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_col_header_height__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_col_header_height__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_col_header_height'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::col_header_height(int)\n"
    "    Fl_Table::col_header_height()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_header_width__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_row_header_width" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_row_header_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->row_header_width(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_header_width__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_row_header_width" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (int)(arg1)->row_header_width(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_header_width(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_row_header_width", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_row_header_width__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_row_header_width__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_row_header_width'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::row_header_width(int)\n"
    "    Fl_Table::row_header_width()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_header_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_row_header_color" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_row_header_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->row_header_color(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_header_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_row_header_color" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (Fl_Color)(arg1)->row_header_color(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_header_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_row_header_color", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_row_header_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_row_header_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_row_header_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::row_header_color(Fl_Color)\n"
    "    Fl_Table::row_header_color()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_header_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_col_header_color" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_col_header_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->col_header_color(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_header_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_col_header_color" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (Fl_Color)(arg1)->col_header_color(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_header_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_col_header_color", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_col_header_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_col_header_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_col_header_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::col_header_color(Fl_Color)\n"
    "    Fl_Table::col_header_color()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_height__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_row_height" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_row_height" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_row_height" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->row_height(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_height__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_row_height" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_row_height" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)(arg1)->row_height(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_height(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_row_height", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_row_height__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Table_row_height__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_row_height'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::row_height(int,int)\n"
    "    Fl_Table::row_height(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_width__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_col_width" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_col_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_col_width" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->col_width(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_width__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_col_width" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_col_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)(arg1)->col_width(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_width(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_col_width", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_col_width__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Table_col_width__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_col_width'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::col_width(int,int)\n"
    "    Fl_Table::col_width(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_height_all(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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, "Fl_Table_row_height_all", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_row_height_all" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_row_height_all" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->row_height_all(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_width_all(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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, "Fl_Table_col_width_all", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_col_width_all" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_col_width_all" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->col_width_all(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_position__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_row_position" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_row_position" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->row_position(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_position__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_col_position" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_col_position" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->col_position(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_position__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_row_position" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (int)(arg1)->row_position(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_position(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_row_position", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_row_position__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_row_position__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_row_position'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::row_position(int)\n"
    "    Fl_Table::row_position()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_position__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_col_position" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (int)(arg1)->col_position(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_position(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_col_position", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_col_position__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_col_position__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_col_position'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::col_position(int)\n"
    "    Fl_Table::col_position()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_top_row__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_top_row" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_top_row" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->top_row(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_top_row__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_top_row" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (int)(arg1)->top_row(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_top_row(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_top_row", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_top_row__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_top_row__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_top_row'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::top_row(int)\n"
    "    Fl_Table::top_row()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_is_selected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Table_is_selected", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_is_selected" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_is_selected" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_is_selected" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)(arg1)->is_selected(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_get_selection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  int temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_get_selection" "', argument " "1"" of type '" "Fl_Table const *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      ((Fl_Table const *)arg1)->get_selection(*arg2,*arg3,*arg4,*arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_set_selection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Table_set_selection", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_set_selection" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_set_selection" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_set_selection" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Table_set_selection" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Table_set_selection" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      (arg1)->set_selection(arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_move_cursor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_move_cursor" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_move_cursor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_move_cursor" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Table_move_cursor" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      result = (int)(arg1)->move_cursor(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_move_cursor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_move_cursor" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_move_cursor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_move_cursor" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)(arg1)->move_cursor(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_move_cursor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_move_cursor", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Table_move_cursor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_Fl_Table_move_cursor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_move_cursor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::move_cursor(int,int,int)\n"
    "    Fl_Table::move_cursor(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Table_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_resize" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Table_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Table_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Table::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_init_sizes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_init_sizes" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      (arg1)->init_sizes(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_add(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Table_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_add" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Table_add" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  {
    try {
      (arg1)->add(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  Fl_Widget *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Table_insert", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_insert" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Widget,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Table_insert" "', argument " "2"" of type '" "Fl_Widget &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Table_insert" "', argument " "2"" of type '" "Fl_Widget &""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_insert" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->insert(*arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_insert_before(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  Fl_Widget *arg2 = 0 ;
  Fl_Widget *arg3 = (Fl_Widget *) 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, "Fl_Table_insert_before", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_insert_before" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Widget,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Table_insert_before" "', argument " "2"" of type '" "Fl_Widget &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Table_insert_before" "', argument " "2"" of type '" "Fl_Widget &""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Table_insert_before" "', argument " "3"" of type '" "Fl_Widget *""'"); 
  }
  arg3 = (Fl_Widget *)(argp3);
  {
    try {
      (arg1)->insert(*arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_begin" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      (arg1)->begin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_end" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      (arg1)->end(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_child(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Table_child", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_child" "', argument " "1"" of type '" "Fl_Table const *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_child" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (Fl_Widget *)((Fl_Table const *)arg1)->child(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Widget, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_children(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_children" "', argument " "1"" of type '" "Fl_Table const *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (int)((Fl_Table const *)arg1)->children(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  Fl_Widget *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, "Fl_Table_find", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_find" "', argument " "1"" of type '" "Fl_Table const *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Widget,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Table_find" "', argument " "2"" of type '" "Fl_Widget const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Table_find" "', argument " "2"" of type '" "Fl_Widget const &""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  {
    try {
      result = (int)((Fl_Table const *)arg1)->find((Fl_Widget const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_callback_row(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_callback_row" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (int)(arg1)->callback_row(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_callback_col(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_callback_col" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (int)(arg1)->callback_col(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_callback_context(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Table::TableContext result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_callback_context" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (Fl_Table::TableContext)(arg1)->callback_context(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_do_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  Fl_Table::TableContext 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 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Table_do_callback", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_do_callback" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_do_callback" "', argument " "2"" of type '" "Fl_Table::TableContext""'");
  } 
  arg2 = (Fl_Table::TableContext)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_do_callback" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Table_do_callback" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      (arg1)->do_callback(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_scrollbar_size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_scrollbar_size" "', argument " "1"" of type '" "Fl_Table const *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (int)((Fl_Table const *)arg1)->scrollbar_size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_scrollbar_size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_scrollbar_size" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_scrollbar_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->scrollbar_size(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_scrollbar_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_scrollbar_size", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_scrollbar_size__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_scrollbar_size__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_scrollbar_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::scrollbar_size() const\n"
    "    Fl_Table::scrollbar_size(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_tab_cell_nav__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_tab_cell_nav" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_tab_cell_nav" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->tab_cell_nav(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_tab_cell_nav__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_tab_cell_nav" "', argument " "1"" of type '" "Fl_Table const *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    try {
      result = (int)((Fl_Table const *)arg1)->tab_cell_nav(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_tab_cell_nav(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_tab_cell_nav", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_tab_cell_nav__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_tab_cell_nav__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_tab_cell_nav'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table::tab_cell_nav(int)\n"
    "    Fl_Table::tab_cell_nav() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 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, "Fl_Table_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_init_type" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Table_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Table_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Table(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Table" "', argument " "1"" of type '" "Fl_Table *""'"); 
  }
  arg1 = (Fl_Table *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Table_Row_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table_Row *arg1 = (Fl_Table_Row *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Table_Row *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Table_Row_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table_Row, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_Row_handle" "', argument " "1"" of type '" "Fl_Table_Row *""'"); 
  }
  arg1 = (Fl_Table_Row *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_Row_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("handle"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member handle");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Table_Row *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)(darg)->handleSwigPublic(arg2);
        } else {
          result = (int)(darg)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Table_Row(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Table_Row *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Table_Row", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Table_Row" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Table_Row" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Table_Row" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Table_Row" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Table_Row" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Table_Row *)new SwigDirector_Fl_Table_Row(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Table_Row *)new Fl_Table_Row(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Table_Row, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Table_Row(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table_Row *arg1 = (Fl_Table_Row *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table_Row, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Table_Row" "', argument " "1"" of type '" "Fl_Table_Row *""'"); 
  }
  arg1 = (Fl_Table_Row *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_rows__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table_Row *arg1 = (Fl_Table_Row *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table_Row, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_Row_rows" "', argument " "1"" of type '" "Fl_Table_Row *""'"); 
  }
  arg1 = (Fl_Table_Row *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_Row_rows" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Table_Row::rows(arg2);
        } else {
          (arg1)->rows(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_rows__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table_Row *arg1 = (Fl_Table_Row *) 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_Fl_Table_Row, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_Row_rows" "', argument " "1"" of type '" "Fl_Table_Row *""'"); 
  }
  arg1 = (Fl_Table_Row *)(argp1);
  {
    try {
      result = (int)(arg1)->rows(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_rows(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_Row_rows", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_Row_rows__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_Row_rows__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_Row_rows'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table_Row::rows(int)\n"
    "    Fl_Table_Row::rows()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_type__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table_Row *arg1 = (Fl_Table_Row *) 0 ;
  Fl_Table_Row::TableRowSelectMode 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_Fl_Table_Row, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_Row_type" "', argument " "1"" of type '" "Fl_Table_Row *""'"); 
  }
  arg1 = (Fl_Table_Row *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_Row_type" "', argument " "2"" of type '" "Fl_Table_Row::TableRowSelectMode""'");
  } 
  arg2 = (Fl_Table_Row::TableRowSelectMode)(val2);
  {
    try {
      (arg1)->type(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_type__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Table_Row *arg1 = (Fl_Table_Row *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Table_Row::TableRowSelectMode result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table_Row, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_Row_type" "', argument " "1"" of type '" "Fl_Table_Row const *""'"); 
  }
  arg1 = (Fl_Table_Row *)(argp1);
  {
    try {
      result = (Fl_Table_Row::TableRowSelectMode)((Fl_Table_Row const *)arg1)->type(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_type(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Table_Row_type", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Table_Row_type__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Table_Row_type__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Table_Row_type'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Table_Row::type(Fl_Table_Row::TableRowSelectMode)\n"
    "    Fl_Table_Row::type() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_row_selected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table_Row *arg1 = (Fl_Table_Row *) 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, "Fl_Table_Row_row_selected", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table_Row, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_Row_row_selected" "', argument " "1"" of type '" "Fl_Table_Row *""'"); 
  }
  arg1 = (Fl_Table_Row *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_Row_row_selected" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)(arg1)->row_selected(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_select_row(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table_Row *arg1 = (Fl_Table_Row *) 0 ;
  int arg2 ;
  int arg3 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Table_Row_select_row", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table_Row, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_Row_select_row" "', argument " "1"" of type '" "Fl_Table_Row *""'"); 
  }
  arg1 = (Fl_Table_Row *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_Row_select_row" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_Row_select_row" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->select_row(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_select_all_rows(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table_Row *arg1 = (Fl_Table_Row *) 0 ;
  int arg2 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Table_Row_select_all_rows", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table_Row, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_Row_select_all_rows" "', argument " "1"" of type '" "Fl_Table_Row *""'"); 
  }
  arg1 = (Fl_Table_Row *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_Row_select_all_rows" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      (arg1)->select_all_rows(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table_Row *arg1 = (Fl_Table_Row *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table_Row, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_Row_clear" "', argument " "1"" of type '" "Fl_Table_Row *""'"); 
  }
  arg1 = (Fl_Table_Row *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Table_Row::clear();
        } else {
          (arg1)->clear();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table_Row *arg1 = (Fl_Table_Row *) 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, "Fl_Table_Row_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table_Row, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_Row_init_type" "', argument " "1"" of type '" "Fl_Table_Row *""'"); 
  }
  arg1 = (Fl_Table_Row *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Table_Row_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Table_Row_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Table_Row(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table_Row *arg1 = (Fl_Table_Row *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table_Row, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Table_Row" "', argument " "1"" of type '" "Fl_Table_Row *""'"); 
  }
  arg1 = (Fl_Table_Row *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table_Row *arg1 = (Fl_Table_Row *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Table_Row *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table_Row, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_Row_draw" "', argument " "1"" of type '" "Fl_Table_Row *""'"); 
  }
  arg1 = (Fl_Table_Row *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Table_Row *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_draw_cell(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table_Row *arg1 = (Fl_Table_Row *) 0 ;
  Fl_Table::TableContext arg2 ;
  int arg3 = (int) 0 ;
  int arg4 = (int) 0 ;
  int arg5 = (int) 0 ;
  int arg6 = (int) 0 ;
  int arg7 = (int) 0 ;
  int arg8 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject *swig_obj[8] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Table_Row *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Table_Row_draw_cell", 2, 8, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Table_Row, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Table_Row_draw_cell" "', argument " "1"" of type '" "Fl_Table_Row *""'"); 
  }
  arg1 = (Fl_Table_Row *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_Row_draw_cell" "', argument " "2"" of type '" "Fl_Table::TableContext""'");
  } 
  arg2 = (Fl_Table::TableContext)(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_Row_draw_cell" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Table_Row_draw_cell" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Table_Row_draw_cell" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = (int)(val5);
  }
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Table_Row_draw_cell" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Table_Row_draw_cell" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  if (swig_obj[7]) {
    ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Fl_Table_Row_draw_cell" "', argument " "8"" of type '" "int""'");
    } 
    arg8 = (int)(val8);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw_cell"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw_cell");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Table_Row *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->draw_cellSwigPublic(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
        } else {
          (darg)->draw_cell(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Tabs_redraw_tabs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Tabs *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_redraw_tabs" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("redraw_tabs"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member redraw_tabs");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Tabs *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->redraw_tabsSwigPublic();
        } else {
          (darg)->redraw_tabs();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_tab_positions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Tabs *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_tab_positions" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("tab_positions"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member tab_positions");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Tabs *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)(darg)->tab_positionsSwigPublic();
        } else {
          result = (int)(darg)->tab_positions();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_clear_tab_positions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Tabs *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_clear_tab_positions" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("clear_tab_positions"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member clear_tab_positions");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Tabs *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->clear_tab_positionsSwigPublic();
        } else {
          (darg)->clear_tab_positions();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_draw_tab(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  Fl_Widget *arg6 = (Fl_Widget *) 0 ;
  int arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject *swig_obj[8] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Tabs *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tabs_draw_tab", 8, 8, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_draw_tab" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tabs_draw_tab" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tabs_draw_tab" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tabs_draw_tab" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Tabs_draw_tab" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Fl_Tabs_draw_tab" "', argument " "6"" of type '" "Fl_Widget *""'"); 
  }
  arg6 = (Fl_Widget *)(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Tabs_draw_tab" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = (int)(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Fl_Tabs_draw_tab" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = (int)(val8);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw_tab"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw_tab");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Tabs *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->draw_tabSwigPublic(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
        } else {
          (darg)->draw_tab(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_tab_height(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Tabs *darg = 0;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_tab_height" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("tab_height"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member tab_height");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Tabs *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)(darg)->tab_heightSwigPublic();
        } else {
          result = (int)(darg)->tab_height();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_hit_close(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Tabs *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tabs_hit_close", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_hit_close" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tabs_hit_close" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tabs_hit_close" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tabs_hit_close" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("hit_close"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member hit_close");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Tabs *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)(darg)->hit_closeSwigPublic(arg2,arg3,arg4);
        } else {
          result = (int)(darg)->hit_close(arg2,arg3,arg4);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_hit_overflow_menu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 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] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Tabs *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tabs_hit_overflow_menu", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_hit_overflow_menu" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tabs_hit_overflow_menu" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tabs_hit_overflow_menu" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("hit_overflow_menu"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member hit_overflow_menu");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Tabs *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)(darg)->hit_overflow_menuSwigPublic(arg2,arg3);
        } else {
          result = (int)(darg)->hit_overflow_menu(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_hit_tabs_area(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 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] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Tabs *darg = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tabs_hit_tabs_area", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_hit_tabs_area" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tabs_hit_tabs_area" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tabs_hit_tabs_area" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("hit_tabs_area"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member hit_tabs_area");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Tabs *>(arg1);
    {
      try {
        if (upcall) {
          result = (int)(darg)->hit_tabs_areaSwigPublic(arg2,arg3);
        } else {
          result = (int)(darg)->hit_tabs_area(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Tabs *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_draw" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Tabs *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Tabs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Tabs *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Tabs", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Tabs" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Tabs" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Tabs" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Tabs" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Tabs" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Tabs *)new SwigDirector_Fl_Tabs(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Tabs *)new Fl_Tabs(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tabs, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Tabs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Tabs" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tabs_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_resize" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tabs_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tabs_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tabs_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Tabs_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Tabs::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_show(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_show" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Tabs::show();
        } else {
          (arg1)->show();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tabs_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_handle" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tabs_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Tabs::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_value" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  {
    try {
      result = (Fl_Widget *)(arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Widget, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_value" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tabs_value" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  {
    try {
      result = (int)(arg1)->value(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tabs_value", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tabs_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tabs_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tabs_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tabs::value()\n"
    "    Fl_Tabs::value(Fl_Widget *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_push__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_push" "', argument " "1"" of type '" "Fl_Tabs const *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  {
    try {
      result = (Fl_Widget *)((Fl_Tabs const *)arg1)->push(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Widget, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_push__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_push" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tabs_push" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  {
    try {
      result = (int)(arg1)->push(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_push(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tabs_push", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tabs_push__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tabs_push__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tabs_push'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tabs::push() const\n"
    "    Fl_Tabs::push(Fl_Widget *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_which(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 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] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Widget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tabs_which", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_which" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tabs_which" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tabs_which" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Widget *)(arg1)->Fl_Tabs::which(arg2,arg3);
        } else {
          result = (Fl_Widget *)(arg1)->which(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Widget, 0 |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_client_area(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int *arg5 = 0 ;
  int arg6 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  int temp5 ;
  int res5 = SWIG_TMPOBJ ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[2] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tabs_client_area", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_client_area" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  if (swig_obj[1]) {
    ecode6 = SWIG_AsVal_int(swig_obj[1], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Tabs_client_area" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  {
    try {
      (arg1)->client_area(*arg2,*arg3,*arg4,*arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_tab_align__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  Fl_Align arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_tab_align" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tabs_tab_align" "', argument " "2"" of type '" "Fl_Align""'");
  } 
  arg2 = (Fl_Align)(val2);
  {
    try {
      (arg1)->tab_align(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_tab_align__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Align result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_tab_align" "', argument " "1"" of type '" "Fl_Tabs const *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  {
    try {
      result = (Fl_Align)((Fl_Tabs const *)arg1)->tab_align(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_tab_align(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tabs_tab_align", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tabs_tab_align__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tabs_tab_align__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tabs_tab_align'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tabs::tab_align(Fl_Align)\n"
    "    Fl_Tabs::tab_align() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_handle_overflow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 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, "Fl_Tabs_handle_overflow", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_handle_overflow" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tabs_handle_overflow" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->handle_overflow(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 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, "Fl_Tabs_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tabs_init_type" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tabs_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Tabs_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Tabs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tabs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Tabs" "', argument " "1"" of type '" "Fl_Tabs *""'"); 
  }
  arg1 = (Fl_Tabs *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Terminal_selection_text_len(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_selection_text_len" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (int)((Fl_Terminal const *)arg1)->selection_text_len(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_selection_text(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_selection_text" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (char *)((Fl_Terminal const *)arg1)->selection_text(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_clear__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_clear" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_clear__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_clear" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_clear" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->clear(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_clear(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_clear", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_clear__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_clear__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_clear'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::clear()\n"
    "    Fl_Terminal::clear(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_clear_screen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  bool arg2 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Terminal_clear_screen", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_clear_screen" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_clear_screen" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = (bool)(val2);
  }
  {
    try {
      (arg1)->clear_screen(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_clear_screen_home(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  bool arg2 = (bool) true ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Terminal_clear_screen_home", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_clear_screen_home" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_clear_screen_home" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = (bool)(val2);
  }
  {
    try {
      (arg1)->clear_screen_home(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_clear_history(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_clear_history" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      (arg1)->clear_history(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_reset_terminal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_reset_terminal" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      (arg1)->reset_terminal(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_cursor_home(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_cursor_home" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      (arg1)->cursor_home(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_cursorfgcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_cursorfgcolor" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_cursorfgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->cursorfgcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_cursorbgcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_cursorbgcolor" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_cursorbgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->cursorbgcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_cursorfgcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_cursorfgcolor" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Terminal const *)arg1)->cursorfgcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_cursorfgcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_cursorfgcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_cursorfgcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_cursorfgcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_cursorfgcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::cursorfgcolor(Fl_Color)\n"
    "    Fl_Terminal::cursorfgcolor() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_cursorbgcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_cursorbgcolor" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Terminal const *)arg1)->cursorbgcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_cursorbgcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_cursorbgcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_cursorbgcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_cursorbgcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_cursorbgcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::cursorbgcolor(Fl_Color)\n"
    "    Fl_Terminal::cursorbgcolor() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_cursor_row(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_cursor_row" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (int)((Fl_Terminal const *)arg1)->cursor_row(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_cursor_col(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_cursor_col" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (int)((Fl_Terminal const *)arg1)->cursor_col(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_output_translate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  Fl_Terminal::OutFlags 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_output_translate" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_output_translate" "', argument " "2"" of type '" "Fl_Terminal::OutFlags""'");
  } 
  arg2 = (Fl_Terminal::OutFlags)(val2);
  {
    try {
      (arg1)->output_translate(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_output_translate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Terminal::OutFlags result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_output_translate" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (Fl_Terminal::OutFlags)((Fl_Terminal const *)arg1)->output_translate(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_output_translate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_output_translate", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_output_translate__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_output_translate__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_output_translate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::output_translate(Fl_Terminal::OutFlags)\n"
    "    Fl_Terminal::output_translate() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_plot_char__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_plot_char" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Terminal_plot_char" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Terminal_plot_char" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Terminal_plot_char" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Terminal_plot_char" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      (arg1)->plot_char((char const *)arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_plot_char__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  char arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_plot_char" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_plot_char" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = (char)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Terminal_plot_char" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Terminal_plot_char" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      (arg1)->plot_char(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_plot_char(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_plot_char", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    PyObject *retobj = _wrap_Fl_Terminal_plot_char__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_Fl_Terminal_plot_char__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_plot_char'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::plot_char(char const *,int,int,int)\n"
    "    Fl_Terminal::plot_char(char,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_print_char__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 = (int) -1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_print_char" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Terminal_print_char" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Terminal_print_char" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      (arg1)->print_char((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_print_char__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_print_char" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_print_char" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = (char)(val2);
  {
    try {
      (arg1)->print_char(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_print_char(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_print_char", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Terminal_print_char__SWIG_1(self, argc, argv);
  }
check_1:
  
  if ((argc >= 2) && (argc <= 3)) {
    PyObject *retobj = _wrap_Fl_Terminal_print_char__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_print_char'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::print_char(char const *,int)\n"
    "    Fl_Terminal::print_char(char)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_append_utf8(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 = (int) -1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Terminal_append_utf8", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_append_utf8" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Terminal_append_utf8" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Terminal_append_utf8" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      (arg1)->append_utf8((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_append_ascii(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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, "Fl_Terminal_append_ascii", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_append_ascii" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Terminal_append_ascii" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->append_ascii((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 = (int) -1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Terminal_append", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_append" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Terminal_append" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Terminal_append" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      (arg1)->append((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_draw" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Terminal::draw();
        } else {
          (arg1)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Terminal_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_resize" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Terminal_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Terminal_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Terminal_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Terminal::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Terminal_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_handle" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Terminal::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_text(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  bool arg2 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Terminal_text", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_text" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_text" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = (bool)(val2);
  }
  {
    try {
      result = (char *)((Fl_Terminal const *)arg1)->text(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_scrollbar_size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_scrollbar_size" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (int)((Fl_Terminal const *)arg1)->scrollbar_size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_scrollbar_size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_scrollbar_size" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_scrollbar_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->scrollbar_size(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_scrollbar_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_scrollbar_size", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_scrollbar_size__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_scrollbar_size__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_scrollbar_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::scrollbar_size() const\n"
    "    Fl_Terminal::scrollbar_size(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_scrollbar_actual_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_scrollbar_actual_size" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (int)((Fl_Terminal const *)arg1)->scrollbar_actual_size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_hscrollbar_style__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  Fl_Terminal::ScrollbarStyle 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_hscrollbar_style" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_hscrollbar_style" "', argument " "2"" of type '" "Fl_Terminal::ScrollbarStyle""'");
  } 
  arg2 = (Fl_Terminal::ScrollbarStyle)(val2);
  {
    try {
      (arg1)->hscrollbar_style(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_hscrollbar_style__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Terminal::ScrollbarStyle result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_hscrollbar_style" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (Fl_Terminal::ScrollbarStyle)((Fl_Terminal const *)arg1)->hscrollbar_style(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_hscrollbar_style(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_hscrollbar_style", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_hscrollbar_style__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_hscrollbar_style__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_hscrollbar_style'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::hscrollbar_style(Fl_Terminal::ScrollbarStyle)\n"
    "    Fl_Terminal::hscrollbar_style() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_history_rows__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_history_rows" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (int)((Fl_Terminal const *)arg1)->history_rows(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_history_rows__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_history_rows" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_history_rows" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->history_rows(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_history_rows(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_history_rows", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_history_rows__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_history_rows__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_history_rows'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::history_rows() const\n"
    "    Fl_Terminal::history_rows(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_history_use(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_history_use" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (int)((Fl_Terminal const *)arg1)->history_use(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_display_rows__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_display_rows" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (int)((Fl_Terminal const *)arg1)->display_rows(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_display_rows__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_display_rows" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_display_rows" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->display_rows(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_display_rows(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_display_rows", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_display_rows__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_display_rows__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_display_rows'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::display_rows() const\n"
    "    Fl_Terminal::display_rows(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_display_columns__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_display_columns" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (int)((Fl_Terminal const *)arg1)->display_columns(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_display_columns__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_display_columns" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_display_columns" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->display_columns(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_display_columns(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_display_columns", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_display_columns__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_display_columns__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_display_columns'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::display_columns() const\n"
    "    Fl_Terminal::display_columns(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_box__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  Fl_Boxtype 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_box" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_box" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = (Fl_Boxtype)(val2);
  {
    try {
      (arg1)->box(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_box__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Boxtype result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_box" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (Fl_Boxtype)((Fl_Terminal const *)arg1)->box(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_box(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_box", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_box__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_box__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_box'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::box(Fl_Boxtype)\n"
    "    Fl_Terminal::box() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_margin_left__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_margin_left" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (int)((Fl_Terminal const *)arg1)->margin_left(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_margin_right__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_margin_right" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (int)((Fl_Terminal const *)arg1)->margin_right(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_margin_top__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_margin_top" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (int)((Fl_Terminal const *)arg1)->margin_top(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_margin_bottom__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_margin_bottom" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (int)((Fl_Terminal const *)arg1)->margin_bottom(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_margin_left__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_margin_left" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_margin_left" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->margin_left(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_margin_left(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_margin_left", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_margin_left__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_margin_left__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_margin_left'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::margin_left() const\n"
    "    Fl_Terminal::margin_left(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_margin_right__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_margin_right" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_margin_right" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->margin_right(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_margin_right(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_margin_right", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_margin_right__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_margin_right__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_margin_right'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::margin_right() const\n"
    "    Fl_Terminal::margin_right(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_margin_top__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_margin_top" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_margin_top" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->margin_top(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_margin_top(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_margin_top", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_margin_top__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_margin_top__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_margin_top'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::margin_top() const\n"
    "    Fl_Terminal::margin_top(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_margin_bottom__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_margin_bottom" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_margin_bottom" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->margin_bottom(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_margin_bottom(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_margin_bottom", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_margin_bottom__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_margin_bottom__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_margin_bottom'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::margin_bottom() const\n"
    "    Fl_Terminal::margin_bottom(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  Fl_Font 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_textfont" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->textfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  Fl_Fontsize 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_textsize" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->textsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_textcolor" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->textcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_color" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->color(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textfgcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_textfgcolor" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_textfgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->textfgcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textbgcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_textbgcolor" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_textbgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->textbgcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textfgcolor_default__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_textfgcolor_default" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_textfgcolor_default" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->textfgcolor_default(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textbgcolor_default__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_textbgcolor_default" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_textbgcolor_default" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->textbgcolor_default(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_textfont" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Terminal const *)arg1)->textfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_textfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_textfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_textfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_textfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::textfont(Fl_Font)\n"
    "    Fl_Terminal::textfont() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_textsize" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Terminal const *)arg1)->textsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_textsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_textsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_textsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_textsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::textsize(Fl_Fontsize)\n"
    "    Fl_Terminal::textsize() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_color" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Terminal const *)arg1)->color(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_color", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::color(Fl_Color)\n"
    "    Fl_Terminal::color() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_textcolor" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Terminal const *)arg1)->textcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_textcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_textcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_textcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_textcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::textcolor(Fl_Color)\n"
    "    Fl_Terminal::textcolor() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textfgcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_textfgcolor" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Terminal const *)arg1)->textfgcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textfgcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_textfgcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_textfgcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_textfgcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_textfgcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::textfgcolor(Fl_Color)\n"
    "    Fl_Terminal::textfgcolor() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textbgcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_textbgcolor" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Terminal const *)arg1)->textbgcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textbgcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_textbgcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_textbgcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_textbgcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_textbgcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::textbgcolor(Fl_Color)\n"
    "    Fl_Terminal::textbgcolor() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textfgcolor_default__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_textfgcolor_default" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Terminal const *)arg1)->textfgcolor_default(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textfgcolor_default(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_textfgcolor_default", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_textfgcolor_default__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_textfgcolor_default__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_textfgcolor_default'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::textfgcolor_default(Fl_Color)\n"
    "    Fl_Terminal::textfgcolor_default() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textbgcolor_default__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_textbgcolor_default" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Terminal const *)arg1)->textbgcolor_default(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textbgcolor_default(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_textbgcolor_default", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_textbgcolor_default__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_textbgcolor_default__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_textbgcolor_default'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::textbgcolor_default(Fl_Color)\n"
    "    Fl_Terminal::textbgcolor_default() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textfgcolor_xterm(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Terminal_textfgcolor_xterm", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_textfgcolor_xterm" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_textfgcolor_xterm" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  {
    try {
      (arg1)->textfgcolor_xterm(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textbgcolor_xterm(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Terminal_textbgcolor_xterm", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_textbgcolor_xterm" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_textbgcolor_xterm" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  {
    try {
      (arg1)->textbgcolor_xterm(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_selectionfgcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_selectionfgcolor" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_selectionfgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->selectionfgcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_selectionbgcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_selectionbgcolor" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_selectionbgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->selectionbgcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_selectionfgcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_selectionfgcolor" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Terminal const *)arg1)->selectionfgcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_selectionfgcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_selectionfgcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_selectionfgcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_selectionfgcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_selectionfgcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::selectionfgcolor(Fl_Color)\n"
    "    Fl_Terminal::selectionfgcolor() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_selectionbgcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_selectionbgcolor" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Terminal const *)arg1)->selectionbgcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_selectionbgcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_selectionbgcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_selectionbgcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_selectionbgcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_selectionbgcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::selectionbgcolor(Fl_Color)\n"
    "    Fl_Terminal::selectionbgcolor() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textattrib__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_textattrib" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_textattrib" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  {
    try {
      (arg1)->textattrib(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textattrib__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_textattrib" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (uchar)((Fl_Terminal const *)arg1)->textattrib(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_textattrib(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_textattrib", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_textattrib__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_textattrib__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_textattrib'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::textattrib(uchar)\n"
    "    Fl_Terminal::textattrib() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_redraw_style__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Terminal::RedrawStyle result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_redraw_style" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (Fl_Terminal::RedrawStyle)((Fl_Terminal const *)arg1)->redraw_style(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_redraw_style__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  Fl_Terminal::RedrawStyle 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_redraw_style" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_redraw_style" "', argument " "2"" of type '" "Fl_Terminal::RedrawStyle""'");
  } 
  arg2 = (Fl_Terminal::RedrawStyle)(val2);
  {
    try {
      (arg1)->redraw_style(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_redraw_style(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_redraw_style", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_redraw_style__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_redraw_style__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_redraw_style'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::redraw_style() const\n"
    "    Fl_Terminal::redraw_style(Fl_Terminal::RedrawStyle)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_redraw_rate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_redraw_rate" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (float)((Fl_Terminal const *)arg1)->redraw_rate(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_float((float)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_redraw_rate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_redraw_rate" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_redraw_rate" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = (float)(val2);
  {
    try {
      (arg1)->redraw_rate(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_redraw_rate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_redraw_rate", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_redraw_rate__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_redraw_rate__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_redraw_rate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::redraw_rate() const\n"
    "    Fl_Terminal::redraw_rate(float)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_show_unknown__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_show_unknown" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (bool)((Fl_Terminal const *)arg1)->show_unknown(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_show_unknown__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_show_unknown" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_show_unknown" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = (bool)(val2);
  {
    try {
      (arg1)->show_unknown(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_show_unknown(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_show_unknown", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_show_unknown__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_show_unknown__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_show_unknown'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::show_unknown() const\n"
    "    Fl_Terminal::show_unknown(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_error_char__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_error_char" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Terminal_error_char" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->error_char((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_error_char__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_error_char" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (char *)((Fl_Terminal const *)arg1)->error_char(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_error_char(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_error_char", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_error_char__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_error_char__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_error_char'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::error_char(char const *)\n"
    "    Fl_Terminal::error_char() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_ansi__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_ansi" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (bool)((Fl_Terminal const *)arg1)->ansi(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_ansi__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_ansi" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_ansi" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = (bool)(val2);
  {
    try {
      (arg1)->ansi(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_ansi(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_ansi", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_ansi__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_ansi__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_ansi'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::ansi() const\n"
    "    Fl_Terminal::ansi(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_history_lines__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_history_lines" "', argument " "1"" of type '" "Fl_Terminal const *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      result = (int)((Fl_Terminal const *)arg1)->history_lines(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_history_lines__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_history_lines" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Terminal_history_lines" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->history_lines(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_history_lines(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Terminal_history_lines", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Terminal_history_lines__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Terminal_history_lines__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Terminal_history_lines'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::history_lines() const\n"
    "    Fl_Terminal::history_lines(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_printf__varargs__(PyObject *self, PyObject *args, PyObject *varargs) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  (void)self;
  if (!PyArg_UnpackTuple(args, "Fl_Terminal_printf", 2, 2, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_printf" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Terminal_printf" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->printf((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_printf(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_Fl_Terminal_printf__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_new_Fl_Terminal__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  Fl_Terminal *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Terminal" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Terminal" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Terminal" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Terminal" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Terminal" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Terminal *)new SwigDirector_Fl_Terminal(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Terminal *)new Fl_Terminal(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Terminal, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Terminal__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  Fl_Terminal *result = 0 ;
  
  (void)self;
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Terminal" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Terminal" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Terminal" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Terminal" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Terminal" "', argument " "6"" of type '" "char const *""'");
  }
  arg6 = (char *)(buf6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Fl_Terminal" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = (int)(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Fl_Terminal" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = (int)(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Fl_Terminal" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = (int)(val9);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Terminal *)new SwigDirector_Fl_Terminal(arg1,arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9); 
      } else {
        result = (Fl_Terminal *)new Fl_Terminal(arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Terminal, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Terminal(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_Terminal", 0, 9, argv))) SWIG_fail;
  --argc;
  if ((argc >= 5) && (argc <= 6)) {
    PyObject *retobj = _wrap_new_Fl_Terminal__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 9) {
    PyObject *retobj = _wrap_new_Fl_Terminal__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_Terminal'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Terminal::Fl_Terminal(int,int,int,int,char const *)\n"
    "    Fl_Terminal::Fl_Terminal(PyObject *,int,int,int,int,char const *,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Terminal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Terminal" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Terminal_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 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, "Fl_Terminal_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Terminal_init_type" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Terminal_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Terminal_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Terminal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Terminal *arg1 = (Fl_Terminal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Terminal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Terminal" "', argument " "1"" of type '" "Fl_Terminal *""'"); 
  }
  arg1 = (Fl_Terminal *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Text_Selection_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Selection *arg1 = (Fl_Text_Selection *) 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, "Fl_Text_Selection_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Selection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Selection_set" "', argument " "1"" of type '" "Fl_Text_Selection *""'"); 
  }
  arg1 = (Fl_Text_Selection *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Selection_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Selection_set" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->set(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Selection_update(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Selection *arg1 = (Fl_Text_Selection *) 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 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Selection_update", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Selection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Selection_update" "', argument " "1"" of type '" "Fl_Text_Selection *""'"); 
  }
  arg1 = (Fl_Text_Selection *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Selection_update" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Selection_update" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Selection_update" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      (arg1)->update(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Selection_start(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Selection *arg1 = (Fl_Text_Selection *) 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_Fl_Text_Selection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Selection_start" "', argument " "1"" of type '" "Fl_Text_Selection const *""'"); 
  }
  arg1 = (Fl_Text_Selection *)(argp1);
  {
    try {
      result = (int)((Fl_Text_Selection const *)arg1)->start(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Selection_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Selection *arg1 = (Fl_Text_Selection *) 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_Fl_Text_Selection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Selection_end" "', argument " "1"" of type '" "Fl_Text_Selection const *""'"); 
  }
  arg1 = (Fl_Text_Selection *)(argp1);
  {
    try {
      result = (int)((Fl_Text_Selection const *)arg1)->end(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Selection_selected__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Selection *arg1 = (Fl_Text_Selection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Selection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Selection_selected" "', argument " "1"" of type '" "Fl_Text_Selection const *""'"); 
  }
  arg1 = (Fl_Text_Selection *)(argp1);
  {
    try {
      result = (bool)((Fl_Text_Selection const *)arg1)->selected(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Selection_selected__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Selection *arg1 = (Fl_Text_Selection *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Selection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Selection_selected" "', argument " "1"" of type '" "Fl_Text_Selection *""'"); 
  }
  arg1 = (Fl_Text_Selection *)(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Selection_selected" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = (bool)(val2);
  {
    try {
      (arg1)->selected(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Selection_length(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Selection *arg1 = (Fl_Text_Selection *) 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_Fl_Text_Selection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Selection_length" "', argument " "1"" of type '" "Fl_Text_Selection const *""'"); 
  }
  arg1 = (Fl_Text_Selection *)(argp1);
  {
    try {
      result = (int)((Fl_Text_Selection const *)arg1)->length(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Selection_includes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Selection *arg1 = (Fl_Text_Selection *) 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, "Fl_Text_Selection_includes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Selection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Selection_includes" "', argument " "1"" of type '" "Fl_Text_Selection const *""'"); 
  }
  arg1 = (Fl_Text_Selection *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Selection_includes" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Text_Selection const *)arg1)->includes(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Selection_selected__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Selection *arg1 = (Fl_Text_Selection *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Selection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Selection_selected" "', argument " "1"" of type '" "Fl_Text_Selection const *""'"); 
  }
  arg1 = (Fl_Text_Selection *)(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 '" "Fl_Text_Selection_selected" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (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 '" "Fl_Text_Selection_selected" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  {
    try {
      result = (int)((Fl_Text_Selection const *)arg1)->selected(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Selection_selected(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Selection_selected", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Selection_selected__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Selection_selected__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Text_Selection_selected__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Selection_selected'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Selection::selected() const\n"
    "    Fl_Text_Selection::selected(bool)\n"
    "    Fl_Text_Selection::selected(int *,int *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Fl_Text_Selection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Selection *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Text_Selection", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Text_Selection *)new Fl_Text_Selection(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Text_Selection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Text_Selection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Selection *arg1 = (Fl_Text_Selection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Selection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Text_Selection" "', argument " "1"" of type '" "Fl_Text_Selection *""'"); 
  }
  arg1 = (Fl_Text_Selection *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Text_Buffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 = (int) 0 ;
  int arg2 = (int) 1024 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Fl_Text_Buffer *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Text_Buffer", 0, 2, swig_obj)) SWIG_fail;
  if (swig_obj[0]) {
    ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Fl_Text_Buffer" "', argument " "1"" of type '" "int""'");
    } 
    arg1 = (int)(val1);
  }
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Text_Buffer" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      result = (Fl_Text_Buffer *)new Fl_Text_Buffer(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Text_Buffer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Text_Buffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Text_Buffer" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_length(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_length" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      result = (int)((Fl_Text_Buffer const *)arg1)->length(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_text__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_text" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      result = (char *)((Fl_Text_Buffer const *)arg1)->text(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_text_str(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_text_str" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      result = ((Fl_Text_Buffer const *)arg1)->text_str(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_std_string((std::string)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_text__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_text" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Buffer_text" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->text((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_text(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_text", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Buffer_text__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Buffer_text__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Buffer_text'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Buffer::text() const\n"
    "    Fl_Text_Buffer::text(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_text_range(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_text_range", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_text_range" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_text_range" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_text_range" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (char *)((Fl_Text_Buffer const *)arg1)->text_range(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_char_at(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_char_at", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_char_at" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_char_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (unsigned int)((Fl_Text_Buffer const *)arg1)->char_at(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_byte_at(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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, "Fl_Text_Buffer_byte_at", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_byte_at" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_byte_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (char)((Fl_Text_Buffer const *)arg1)->byte_at(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new char(result)), SWIGTYPE_p_char, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_address__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_address" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_address" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (char *)((Fl_Text_Buffer const *)arg1)->address(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_address__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_address" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_address" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (char *)(arg1)->address(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_address(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_address", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Buffer_address__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Buffer_address__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Buffer_address'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Buffer::address(int) const\n"
    "    Fl_Text_Buffer::address(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  int arg4 = (int) -1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_insert", 3, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_insert" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_insert" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Text_Buffer_insert" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Buffer_insert" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  {
    try {
      (arg1)->insert(arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 = (int) -1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_append", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_append" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Buffer_append" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_append" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      (arg1)->append((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_printf__varargs__(PyObject *self, PyObject *args, PyObject *varargs) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  (void)self;
  if (!PyArg_UnpackTuple(args, "Fl_Text_Buffer_printf", 2, 2, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_printf" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Buffer_printf" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->printf((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_printf(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_Fl_Text_Buffer_printf__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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, "Fl_Text_Buffer_remove", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_remove" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_remove" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->remove(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_replace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  int arg2 ;
  int arg3 ;
  char *arg4 = (char *) 0 ;
  int arg5 = (int) -1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_replace", 4, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_replace" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_replace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_replace" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Text_Buffer_replace" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = (char *)(buf4);
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Text_Buffer_replace" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = (int)(val5);
  }
  {
    try {
      (arg1)->replace(arg2,arg3,(char const *)arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  Fl_Text_Buffer *arg2 = (Fl_Text_Buffer *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_copy", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_copy" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Buffer_copy" "', argument " "2"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg2 = (Fl_Text_Buffer *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_copy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Buffer_copy" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Text_Buffer_copy" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  {
    try {
      (arg1)->copy(arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_undo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  int *arg2 = (int *) 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, "Fl_Text_Buffer_undo", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_undo" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Buffer_undo" "', argument " "2"" of type '" "int *""'"); 
    }
    arg2 = (int *)(argp2);
  }
  {
    try {
      result = (int)(arg1)->undo(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_can_undo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_can_undo" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      result = (bool)((Fl_Text_Buffer const *)arg1)->can_undo(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_redo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  int *arg2 = (int *) 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, "Fl_Text_Buffer_redo", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_redo" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Buffer_redo" "', argument " "2"" of type '" "int *""'"); 
    }
    arg2 = (int *)(argp2);
  }
  {
    try {
      result = (int)(arg1)->redo(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_can_redo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_can_redo" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      result = (bool)((Fl_Text_Buffer const *)arg1)->can_redo(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_canUndo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  char arg2 = (char) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_canUndo", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_canUndo" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_canUndo" "', argument " "2"" of type '" "char""'");
    } 
    arg2 = (char)(val2);
  }
  {
    try {
      (arg1)->canUndo(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_insertfile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int arg4 = (int) 128*1024 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_insertfile", 3, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_insertfile" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Buffer_insertfile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_insertfile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Buffer_insertfile" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  {
    try {
      result = (int)(arg1)->insertfile((char const *)arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_appendfile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 = (int) 128*1024 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_appendfile", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_appendfile" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Buffer_appendfile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_appendfile" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->appendfile((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_loadfile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 = (int) 128*1024 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_loadfile", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_loadfile" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Buffer_loadfile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_loadfile" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->loadfile((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_outputfile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 = (int) 128*1024 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_outputfile", 4, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_outputfile" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Buffer_outputfile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_outputfile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Buffer_outputfile" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Text_Buffer_outputfile" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = (int)(val5);
  }
  {
    try {
      result = (int)(arg1)->outputfile((char const *)arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_savefile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 = (int) 128*1024 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_savefile", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_savefile" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Buffer_savefile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_savefile" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->savefile((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_tab_distance__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_tab_distance" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      result = (int)((Fl_Text_Buffer const *)arg1)->tab_distance(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_tab_distance__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_tab_distance" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_tab_distance" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->tab_distance(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_tab_distance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_tab_distance", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Buffer_tab_distance__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Buffer_tab_distance__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Buffer_tab_distance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Buffer::tab_distance() const\n"
    "    Fl_Text_Buffer::tab_distance(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_select(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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, "Fl_Text_Buffer_select", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_select" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_select" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_select" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->select(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_selected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_selected" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      result = (int)((Fl_Text_Buffer const *)arg1)->selected(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_unselect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_unselect" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      (arg1)->unselect(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_selection_position(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_selection_position", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_selection_position" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(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 '" "Fl_Text_Buffer_selection_position" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (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 '" "Fl_Text_Buffer_selection_position" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  {
    try {
      result = (int)(arg1)->selection_position(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_selection_text(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_selection_text" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      result = (char *)(arg1)->selection_text(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_remove_selection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_remove_selection" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      (arg1)->remove_selection(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_replace_selection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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, "Fl_Text_Buffer_replace_selection", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_replace_selection" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Buffer_replace_selection" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->replace_selection((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_secondary_select(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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, "Fl_Text_Buffer_secondary_select", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_secondary_select" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_secondary_select" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_secondary_select" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->secondary_select(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_secondary_selected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_secondary_selected" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      result = (int)(arg1)->secondary_selected(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_secondary_unselect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_secondary_unselect" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      (arg1)->secondary_unselect(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_secondary_selection_position(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_secondary_selection_position", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_secondary_selection_position" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(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 '" "Fl_Text_Buffer_secondary_selection_position" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (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 '" "Fl_Text_Buffer_secondary_selection_position" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  {
    try {
      result = (int)(arg1)->secondary_selection_position(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_secondary_selection_text(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_secondary_selection_text" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      result = (char *)(arg1)->secondary_selection_text(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_remove_secondary_selection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_remove_secondary_selection" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      (arg1)->remove_secondary_selection(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_replace_secondary_selection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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, "Fl_Text_Buffer_replace_secondary_selection", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_replace_secondary_selection" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Buffer_replace_secondary_selection" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->replace_secondary_selection((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_highlight__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_highlight" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_highlight" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_highlight" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->highlight(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_highlight__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_highlight" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      result = (int)(arg1)->highlight(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_highlight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_highlight", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Buffer_highlight__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Text_Buffer_highlight__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Buffer_highlight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Buffer::highlight(int,int)\n"
    "    Fl_Text_Buffer::highlight()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_unhighlight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_unhighlight" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      (arg1)->unhighlight(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_highlight_position(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_highlight_position", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_highlight_position" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(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 '" "Fl_Text_Buffer_highlight_position" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (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 '" "Fl_Text_Buffer_highlight_position" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  {
    try {
      result = (int)(arg1)->highlight_position(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_highlight_text(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_highlight_text" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      result = (char *)(arg1)->highlight_text(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_add_modify_callback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  Fl_Text_Modify_Cb arg2 = (Fl_Text_Modify_Cb) 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_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_add_modify_callback" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_int_int_int_int_p_q_const__char_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Text_Buffer_add_modify_callback" "', argument " "2"" of type '" "Fl_Text_Modify_Cb""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Text_Buffer_add_modify_callback" "', argument " "3"" of type '" "void *""'"); 
  }
  {
    try {
      (arg1)->add_modify_callback(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_remove_modify_callback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  Fl_Text_Modify_Cb arg2 = (Fl_Text_Modify_Cb) 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_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_remove_modify_callback" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_int_int_int_int_p_q_const__char_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Text_Buffer_remove_modify_callback" "', argument " "2"" of type '" "Fl_Text_Modify_Cb""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Text_Buffer_remove_modify_callback" "', argument " "3"" of type '" "void *""'"); 
  }
  {
    try {
      (arg1)->remove_modify_callback(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_call_modify_callbacks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_call_modify_callbacks" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      (arg1)->call_modify_callbacks(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_add_predelete_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  Fl_Text_Predelete_Cb arg2 = (Fl_Text_Predelete_Cb) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_add_predelete_callback", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_add_predelete_callback" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_int_int_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Text_Buffer_add_predelete_callback" "', argument " "2"" of type '" "Fl_Text_Predelete_Cb""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Text_Buffer_add_predelete_callback" "', argument " "3"" of type '" "void *""'"); 
  }
  {
    try {
      (arg1)->add_predelete_callback(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_remove_predelete_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  Fl_Text_Predelete_Cb arg2 = (Fl_Text_Predelete_Cb) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_remove_predelete_callback", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_remove_predelete_callback" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_int_int_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Text_Buffer_remove_predelete_callback" "', argument " "2"" of type '" "Fl_Text_Predelete_Cb""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Text_Buffer_remove_predelete_callback" "', argument " "3"" of type '" "void *""'"); 
  }
  {
    try {
      (arg1)->remove_predelete_callback(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_call_predelete_callbacks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_call_predelete_callbacks" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      (arg1)->call_predelete_callbacks(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_line_text(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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, "Fl_Text_Buffer_line_text", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_line_text" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_line_text" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (char *)((Fl_Text_Buffer const *)arg1)->line_text(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_line_start(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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, "Fl_Text_Buffer_line_start", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_line_start" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_line_start" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Text_Buffer const *)arg1)->line_start(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_line_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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, "Fl_Text_Buffer_line_end", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_line_end" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_line_end" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Text_Buffer const *)arg1)->line_end(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_word_start(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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, "Fl_Text_Buffer_word_start", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_word_start" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_word_start" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Text_Buffer const *)arg1)->word_start(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_word_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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, "Fl_Text_Buffer_word_end", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_word_end" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_word_end" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Text_Buffer const *)arg1)->word_end(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_count_displayed_characters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_count_displayed_characters", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_count_displayed_characters" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_count_displayed_characters" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_count_displayed_characters" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)((Fl_Text_Buffer const *)arg1)->count_displayed_characters(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_skip_displayed_characters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_skip_displayed_characters", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_skip_displayed_characters" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_skip_displayed_characters" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_skip_displayed_characters" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)(arg1)->skip_displayed_characters(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_count_lines(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_count_lines", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_count_lines" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_count_lines" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_count_lines" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)((Fl_Text_Buffer const *)arg1)->count_lines(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_estimate_lines(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_estimate_lines", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_estimate_lines" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_estimate_lines" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_estimate_lines" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Buffer_estimate_lines" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      result = (int)((Fl_Text_Buffer const *)arg1)->estimate_lines(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_skip_lines(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_skip_lines", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_skip_lines" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_skip_lines" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_skip_lines" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)(arg1)->skip_lines(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_rewind_lines(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_rewind_lines", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_rewind_lines" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_rewind_lines" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_rewind_lines" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)(arg1)->rewind_lines(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_findchar_forward(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  int arg2 ;
  unsigned int arg3 ;
  int *arg4 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  int result;
  
  arg4 = &temp4;
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_findchar_forward", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_findchar_forward" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_findchar_forward" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_findchar_forward" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = (unsigned int)(val3);
  {
    try {
      result = (int)((Fl_Text_Buffer const *)arg1)->findchar_forward(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_findchar_backward(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  int arg2 ;
  unsigned int arg3 ;
  int *arg4 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  int result;
  
  arg4 = &temp4;
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_findchar_backward", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_findchar_backward" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_findchar_backward" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_findchar_backward" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = (unsigned int)(val3);
  {
    try {
      result = (int)((Fl_Text_Buffer const *)arg1)->findchar_backward(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_search_forward(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  int *arg4 = (int *) 0 ;
  int arg5 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  arg4 = &temp4;
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_search_forward", 3, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_search_forward" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_search_forward" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Text_Buffer_search_forward" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  if (swig_obj[3]) {
    ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Text_Buffer_search_forward" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = (int)(val5);
  }
  {
    try {
      result = (int)((Fl_Text_Buffer const *)arg1)->search_forward(arg2,(char const *)arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 0);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_search_backward(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  int *arg4 = (int *) 0 ;
  int arg5 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  arg4 = &temp4;
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_search_backward", 3, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_search_backward" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_search_backward" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Text_Buffer_search_backward" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  if (swig_obj[3]) {
    ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Text_Buffer_search_backward" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = (int)(val5);
  }
  {
    try {
      result = (int)((Fl_Text_Buffer const *)arg1)->search_backward(arg2,(char const *)arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 0);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_primary_selection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Text_Selection *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_primary_selection" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      result = (Fl_Text_Selection *)((Fl_Text_Buffer const *)arg1)->primary_selection(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Text_Selection, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_primary_selection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Text_Selection *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_primary_selection" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      result = (Fl_Text_Selection *)(arg1)->primary_selection(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Text_Selection, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_primary_selection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_primary_selection", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Buffer_primary_selection__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Buffer_primary_selection__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Buffer_primary_selection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Buffer::primary_selection() const\n"
    "    Fl_Text_Buffer::primary_selection()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_secondary_selection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Text_Selection *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_secondary_selection" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      result = (Fl_Text_Selection *)((Fl_Text_Buffer const *)arg1)->secondary_selection(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Text_Selection, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_highlight_selection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Text_Selection *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_highlight_selection" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    try {
      result = (Fl_Text_Selection *)((Fl_Text_Buffer const *)arg1)->highlight_selection(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Text_Selection, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_prev_char(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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, "Fl_Text_Buffer_prev_char", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_prev_char" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_prev_char" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Text_Buffer const *)arg1)->prev_char(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_prev_char_clipped(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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, "Fl_Text_Buffer_prev_char_clipped", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_prev_char_clipped" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_prev_char_clipped" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Text_Buffer const *)arg1)->prev_char_clipped(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_next_char(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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, "Fl_Text_Buffer_next_char", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_next_char" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_next_char" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Text_Buffer const *)arg1)->next_char(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_next_char_clipped(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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, "Fl_Text_Buffer_next_char_clipped", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_next_char_clipped" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_next_char_clipped" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Text_Buffer const *)arg1)->next_char_clipped(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_utf8_align(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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, "Fl_Text_Buffer_utf8_align", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_utf8_align" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_utf8_align" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Text_Buffer const *)arg1)->utf8_align(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_is_word_separator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_is_word_separator", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_is_word_separator" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_is_word_separator" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (bool)((Fl_Text_Buffer const *)arg1)->is_word_separator(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_add_modify_callback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_add_modify_callback" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  if (swig_obj[2]) {
    arg3 = swig_obj[2];
  }
  {
    try {
      Fl_Text_Buffer_add_modify_callback__SWIG_1(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_add_modify_callback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_add_modify_callback", 0, 3, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    {
      _v = (argv[1] != 0);
    }
    if (!_v) goto check_1;
    if (argc > 2) {
      {
        _v = (argv[2] != 0);
      }
      if (!_v) goto check_1;
    }
    return _wrap_Fl_Text_Buffer_add_modify_callback__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Text_Buffer_add_modify_callback__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Buffer_add_modify_callback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Buffer::add_modify_callback(Fl_Text_Modify_Cb,void *)\n"
    "    Fl_Text_Buffer::add_modify_callback(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_remove_modify_callback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  PyObject *arg4 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Buffer_remove_modify_callback" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = (Fl_Text_Buffer *)(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];
  arg4 = swig_obj[3];
  {
    try {
      Fl_Text_Buffer_remove_modify_callback__SWIG_1(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_remove_modify_callback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Buffer_remove_modify_callback", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Text_Buffer_remove_modify_callback__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_Fl_Text_Buffer_remove_modify_callback__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Buffer_remove_modify_callback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Buffer::remove_modify_callback(Fl_Text_Modify_Cb,void *)\n"
    "    Fl_Text_Buffer::remove_modify_callback(PyObject *,PyObject *,PyObject *)\n");
  return 0;
}


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

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

SWIGINTERN PyObject *_wrap_new_Style_Table_Entry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Style_Table_Entry *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Style_Table_Entry", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Style_Table_Entry *)new Style_Table_Entry(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Style_Table_Entry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Style_Table_Entry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Style_Table_Entry *arg1 = (Style_Table_Entry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Style_Table_Entry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Style_Table_Entry" "', argument " "1"" of type '" "Style_Table_Entry *""'"); 
  }
  arg1 = (Style_Table_Entry *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Text_Display(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Text_Display *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Text_Display", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Text_Display" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Text_Display" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Text_Display" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Text_Display" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Text_Display" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Text_Display *)new SwigDirector_Fl_Text_Display(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Text_Display *)new Fl_Text_Display(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Text_Display, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Text_Display(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Text_Display" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Display_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_handle" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Text_Display::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_buffer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  Fl_Text_Buffer *arg2 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_buffer" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Display_buffer" "', argument " "2"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg2 = (Fl_Text_Buffer *)(argp2);
  {
    try {
      (arg1)->buffer(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_buffer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Text_Buffer *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_buffer" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (Fl_Text_Buffer *)((Fl_Text_Display const *)arg1)->buffer(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_buffer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_buffer", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_buffer__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_buffer__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_buffer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::buffer(Fl_Text_Buffer *)\n"
    "    Fl_Text_Display::buffer() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_style_buffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Text_Buffer *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_style_buffer" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (Fl_Text_Buffer *)((Fl_Text_Display const *)arg1)->style_buffer(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_redisplay_range(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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, "Fl_Text_Display_redisplay_range", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_redisplay_range" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_redisplay_range" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_redisplay_range" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->redisplay_range(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_scroll(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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, "Fl_Text_Display_scroll", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_scroll" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_scroll" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_scroll" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->scroll(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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, "Fl_Text_Display_insert", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_insert" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Display_insert" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->insert((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_overstrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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, "Fl_Text_Display_overstrike", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_overstrike" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Display_overstrike" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->overstrike((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_insert_position__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_insert_position" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_insert_position" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->insert_position(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_insert_position__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_insert_position" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (int)((Fl_Text_Display const *)arg1)->insert_position(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_insert_position(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_insert_position", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_insert_position__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_insert_position__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_insert_position'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::insert_position(int)\n"
    "    Fl_Text_Display::insert_position() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_position_to_xy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  int arg2 ;
  int *arg3 = (int *) 0 ;
  int *arg4 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Display_position_to_xy", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_position_to_xy" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_position_to_xy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (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 '" "Fl_Text_Display_position_to_xy" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Text_Display_position_to_xy" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  {
    try {
      result = (int)((Fl_Text_Display const *)arg1)->position_to_xy(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_in_selection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Display_in_selection", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_in_selection" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_in_selection" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_in_selection" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)((Fl_Text_Display const *)arg1)->in_selection(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_show_insert_position(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_show_insert_position" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      (arg1)->show_insert_position(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_move_right(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_move_right" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (int)(arg1)->move_right(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_move_left(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_move_left" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (int)(arg1)->move_left(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_move_up(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_move_up" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (int)(arg1)->move_up(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_move_down(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_move_down" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (int)(arg1)->move_down(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_count_lines(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  int arg2 ;
  int arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Display_count_lines", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_count_lines" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_count_lines" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_count_lines" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Display_count_lines" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = (bool)(val4);
  {
    try {
      result = (int)((Fl_Text_Display const *)arg1)->count_lines(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_line_start(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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, "Fl_Text_Display_line_start", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_line_start" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_line_start" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Text_Display const *)arg1)->line_start(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_line_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Display_line_end", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_line_end" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_line_end" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_line_end" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = (bool)(val3);
  {
    try {
      result = (int)((Fl_Text_Display const *)arg1)->line_end(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_skip_lines(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  int arg2 ;
  int arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Display_skip_lines", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_skip_lines" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_skip_lines" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_skip_lines" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Display_skip_lines" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = (bool)(val4);
  {
    try {
      result = (int)(arg1)->skip_lines(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_rewind_lines(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Display_rewind_lines", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_rewind_lines" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_rewind_lines" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_rewind_lines" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)(arg1)->rewind_lines(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_next_word(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_next_word" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      (arg1)->next_word(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_previous_word(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_previous_word" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      (arg1)->previous_word(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_show_cursor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  int arg2 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Display_show_cursor", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_show_cursor" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_show_cursor" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      (arg1)->show_cursor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_hide_cursor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_hide_cursor" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      (arg1)->hide_cursor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_cursor_style__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_cursor_style" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_cursor_style" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->cursor_style(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_cursor_style__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_cursor_style" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (int)((Fl_Text_Display const *)arg1)->cursor_style(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_cursor_style(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_cursor_style", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_cursor_style__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_cursor_style__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_cursor_style'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::cursor_style(int)\n"
    "    Fl_Text_Display::cursor_style() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_cursor_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_cursor_color" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Text_Display const *)arg1)->cursor_color(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_cursor_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_cursor_color" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_cursor_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->cursor_color(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_cursor_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_cursor_color", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_cursor_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_cursor_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_cursor_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::cursor_color() const\n"
    "    Fl_Text_Display::cursor_color(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_scrollbar_width__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_scrollbar_width" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (int)((Fl_Text_Display const *)arg1)->scrollbar_width(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_scrollbar_width__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_scrollbar_width" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_scrollbar_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->scrollbar_width(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_scrollbar_width(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_scrollbar_width", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_scrollbar_width__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_scrollbar_width__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_scrollbar_width'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::scrollbar_width() const\n"
    "    Fl_Text_Display::scrollbar_width(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_scrollbar_size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_scrollbar_size" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (int)((Fl_Text_Display const *)arg1)->scrollbar_size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_scrollbar_size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_scrollbar_size" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_scrollbar_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->scrollbar_size(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_scrollbar_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_scrollbar_size", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_scrollbar_size__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_scrollbar_size__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_scrollbar_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::scrollbar_size() const\n"
    "    Fl_Text_Display::scrollbar_size(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_scrollbar_align__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Align result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_scrollbar_align" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (Fl_Align)((Fl_Text_Display const *)arg1)->scrollbar_align(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_scrollbar_align__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  Fl_Align arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_scrollbar_align" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_scrollbar_align" "', argument " "2"" of type '" "Fl_Align""'");
  } 
  arg2 = (Fl_Align)(val2);
  {
    try {
      (arg1)->scrollbar_align(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_scrollbar_align(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_scrollbar_align", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_scrollbar_align__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_scrollbar_align__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_scrollbar_align'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::scrollbar_align() const\n"
    "    Fl_Text_Display::scrollbar_align(Fl_Align)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_word_start(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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, "Fl_Text_Display_word_start", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_word_start" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_word_start" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Text_Display const *)arg1)->word_start(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_word_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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, "Fl_Text_Display_word_end", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_word_end" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_word_end" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Text_Display const *)arg1)->word_end(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_position_style(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Display_position_style", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_position_style" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_position_style" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_position_style" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Display_position_style" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      result = (int)((Fl_Text_Display const *)arg1)->position_style(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_shortcut__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_shortcut" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (int)((Fl_Text_Display const *)arg1)->shortcut(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_shortcut__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_shortcut" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_shortcut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->shortcut(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_shortcut(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_shortcut", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_shortcut__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_shortcut__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_shortcut'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::shortcut() const\n"
    "    Fl_Text_Display::shortcut(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_textfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_textfont" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Text_Display const *)arg1)->textfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_textfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  Fl_Font 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_textfont" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->textfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_textfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_textfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_textfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_textfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_textfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::textfont() const\n"
    "    Fl_Text_Display::textfont(Fl_Font)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_textsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_textsize" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Text_Display const *)arg1)->textsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_textsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  Fl_Fontsize 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_textsize" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->textsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_textsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_textsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_textsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_textsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_textsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::textsize() const\n"
    "    Fl_Text_Display::textsize(Fl_Fontsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_textcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_textcolor" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Text_Display const *)arg1)->textcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_textcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_textcolor" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->textcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_textcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_textcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_textcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_textcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_textcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::textcolor() const\n"
    "    Fl_Text_Display::textcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_grammar_underline_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_grammar_underline_color" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_grammar_underline_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->grammar_underline_color(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_grammar_underline_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_grammar_underline_color" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Text_Display const *)arg1)->grammar_underline_color(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_grammar_underline_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_grammar_underline_color", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_grammar_underline_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_grammar_underline_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_grammar_underline_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::grammar_underline_color(Fl_Color)\n"
    "    Fl_Text_Display::grammar_underline_color() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_spelling_underline_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_spelling_underline_color" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_spelling_underline_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->spelling_underline_color(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_spelling_underline_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_spelling_underline_color" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Text_Display const *)arg1)->spelling_underline_color(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_spelling_underline_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_spelling_underline_color", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_spelling_underline_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_spelling_underline_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_spelling_underline_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::spelling_underline_color(Fl_Color)\n"
    "    Fl_Text_Display::spelling_underline_color() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_secondary_selection_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_secondary_selection_color" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_secondary_selection_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->secondary_selection_color(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_secondary_selection_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_secondary_selection_color" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Text_Display const *)arg1)->secondary_selection_color(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_secondary_selection_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_secondary_selection_color", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_secondary_selection_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_secondary_selection_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_secondary_selection_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::secondary_selection_color(Fl_Color)\n"
    "    Fl_Text_Display::secondary_selection_color() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_wrapped_column(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Display_wrapped_column", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_wrapped_column" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_wrapped_column" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_wrapped_column" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)((Fl_Text_Display const *)arg1)->wrapped_column(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_wrapped_row(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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, "Fl_Text_Display_wrapped_row", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_wrapped_row" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_wrapped_row" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)((Fl_Text_Display const *)arg1)->wrapped_row(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_wrap_mode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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, "Fl_Text_Display_wrap_mode", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_wrap_mode" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_wrap_mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_wrap_mode" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->wrap_mode(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_recalc_display(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_recalc_display" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Text_Display::recalc_display();
        } else {
          (arg1)->recalc_display();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_display_needs_recalc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_display_needs_recalc" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Text_Display::display_needs_recalc();
        } else {
          (arg1)->display_needs_recalc();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Display_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_resize" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Display_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Text_Display_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Text_Display::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_x_to_col(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Display_x_to_col", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_x_to_col" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_x_to_col" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      result = (double)((Fl_Text_Display const *)arg1)->x_to_col(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_col_to_x(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Display_col_to_x", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_col_to_x" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_col_to_x" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = (double)(val2);
  {
    try {
      result = (double)((Fl_Text_Display const *)arg1)->col_to_x(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_double((double)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_width__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_linenumber_width" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_linenumber_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->linenumber_width(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_width__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_linenumber_width" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (int)((Fl_Text_Display const *)arg1)->linenumber_width(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_width(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_linenumber_width", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_linenumber_width__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_linenumber_width__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_linenumber_width'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::linenumber_width(int)\n"
    "    Fl_Text_Display::linenumber_width() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_font__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  Fl_Font 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_linenumber_font" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_linenumber_font" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->linenumber_font(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_font__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_linenumber_font" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Text_Display const *)arg1)->linenumber_font(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_font(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_linenumber_font", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_linenumber_font__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_linenumber_font__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_linenumber_font'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::linenumber_font(Fl_Font)\n"
    "    Fl_Text_Display::linenumber_font() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  Fl_Fontsize 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_linenumber_size" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_linenumber_size" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->linenumber_size(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_linenumber_size" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Text_Display const *)arg1)->linenumber_size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_linenumber_size", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_linenumber_size__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_linenumber_size__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_linenumber_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::linenumber_size(Fl_Fontsize)\n"
    "    Fl_Text_Display::linenumber_size() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_fgcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_linenumber_fgcolor" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_linenumber_fgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->linenumber_fgcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_fgcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_linenumber_fgcolor" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Text_Display const *)arg1)->linenumber_fgcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_fgcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_linenumber_fgcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_linenumber_fgcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_linenumber_fgcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_linenumber_fgcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::linenumber_fgcolor(Fl_Color)\n"
    "    Fl_Text_Display::linenumber_fgcolor() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_bgcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_linenumber_bgcolor" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_linenumber_bgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->linenumber_bgcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_bgcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_linenumber_bgcolor" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Text_Display const *)arg1)->linenumber_bgcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_bgcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_linenumber_bgcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_linenumber_bgcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_linenumber_bgcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_linenumber_bgcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::linenumber_bgcolor(Fl_Color)\n"
    "    Fl_Text_Display::linenumber_bgcolor() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_align__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  Fl_Align arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_linenumber_align" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_linenumber_align" "', argument " "2"" of type '" "Fl_Align""'");
  } 
  arg2 = (Fl_Align)(val2);
  {
    try {
      (arg1)->linenumber_align(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_align__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Align result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_linenumber_align" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (Fl_Align)((Fl_Text_Display const *)arg1)->linenumber_align(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_align(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_linenumber_align", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_linenumber_align__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_linenumber_align__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_linenumber_align'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::linenumber_align(Fl_Align)\n"
    "    Fl_Text_Display::linenumber_align() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_format__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_linenumber_format" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Display_linenumber_format" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->linenumber_format((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_format__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_linenumber_format" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (char *)((Fl_Text_Display const *)arg1)->linenumber_format(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_format(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Display_linenumber_format", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Display_linenumber_format__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Display_linenumber_format__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Display_linenumber_format'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Display::linenumber_format(char const *)\n"
    "    Fl_Text_Display::linenumber_format() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Text_Display *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_draw" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Text_Display *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_get_absolute_top_line_number(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_get_absolute_top_line_number" "', argument " "1"" of type '" "Fl_Text_Display const *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (int)((Fl_Text_Display const *)arg1)->get_absolute_top_line_number(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_scroll_row(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_scroll_row" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (int)(arg1)->scroll_row(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_scroll_col(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_scroll_col" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    try {
      result = (int)(arg1)->scroll_col(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 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, "Fl_Text_Display_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_init_type" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Display_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Text_Display_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_highlight_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  Fl_Text_Buffer *arg2 = (Fl_Text_Buffer *) 0 ;
  Fl_Text_Display::Style_Table_Entry *arg3 = (Fl_Text_Display::Style_Table_Entry *) 0 ;
  int arg4 ;
  char arg5 ;
  PyObject *arg6 = (PyObject *) 0 ;
  PyObject *arg7 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[7] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Display_highlight_data", 7, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Display_highlight_data" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Buffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Display_highlight_data" "', argument " "2"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg2 = (Fl_Text_Buffer *)(argp2);
  {
    // Check if it is a list
    if (PyList_Check(swig_obj[2])) {
      Py_ssize_t size = PyList_Size(swig_obj[2]);
      int i = 0;
      arg3 = (Style_Table_Entry*) malloc((size)*sizeof(Style_Table_Entry));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[2],i);
        if (PyList_Check(o)) {
          Py_ssize_t item_size = PyList_Size(o);
          arg3[i].color = (Fl_Color)PyInt_AsLong(PyList_GetItem(o,0));
          arg3[i].font = (Fl_Font)PyInt_AsLong(PyList_GetItem(o,1));
          arg3[i].size = PyInt_AsLong(PyList_GetItem(o,2));
          if (item_size > 3)
          arg3[i].attr = PyInt_AsLong(PyList_GetItem(o,3));
        }
      }
    }
    else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Display_highlight_data" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Text_Display_highlight_data" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = (char)(val5);
  arg6 = swig_obj[5];
  arg7 = swig_obj[6];
  {
    try {
      Fl_Text_Display_highlight_data_new(arg1,arg2,(Fl_Text_Display::Style_Table_Entry const *)arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Text_Display(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Display, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Text_Display" "', argument " "1"" of type '" "Fl_Text_Display *""'"); 
  }
  arg1 = (Fl_Text_Display *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Text_Editor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Text_Editor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Text_Editor", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Text_Editor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Text_Editor" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Text_Editor" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Text_Editor" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Text_Editor" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Text_Editor *)new SwigDirector_Fl_Text_Editor(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Text_Editor *)new Fl_Text_Editor(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Text_Editor, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Text_Editor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Editor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Text_Editor" "', argument " "1"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg1 = (Fl_Text_Editor *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Editor_handle" "', argument " "1"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg1 = (Fl_Text_Editor *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Editor_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Text_Editor::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_insert_mode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 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_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Editor_insert_mode" "', argument " "1"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg1 = (Fl_Text_Editor *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Editor_insert_mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->insert_mode(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_insert_mode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 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_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Editor_insert_mode" "', argument " "1"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg1 = (Fl_Text_Editor *)(argp1);
  {
    try {
      result = (int)(arg1)->insert_mode(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_insert_mode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_insert_mode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Editor_insert_mode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Editor_insert_mode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Editor_insert_mode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Editor::insert_mode(int)\n"
    "    Fl_Text_Editor::insert_mode()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_tab_nav__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 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_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Editor_tab_nav" "', argument " "1"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg1 = (Fl_Text_Editor *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Editor_tab_nav" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->tab_nav(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_tab_nav__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 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_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Editor_tab_nav" "', argument " "1"" of type '" "Fl_Text_Editor const *""'"); 
  }
  arg1 = (Fl_Text_Editor *)(argp1);
  {
    try {
      result = (int)((Fl_Text_Editor const *)arg1)->tab_nav(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_tab_nav(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_tab_nav", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Text_Editor_tab_nav__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Text_Editor_tab_nav__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Editor_tab_nav'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Editor::tab_nav(int)\n"
    "    Fl_Text_Editor::tab_nav() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_add_key_binding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 0 ;
  int arg2 ;
  int arg3 ;
  Fl_Text_Editor::Key_Func arg4 = (Fl_Text_Editor::Key_Func) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_add_key_binding", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Editor_add_key_binding" "', argument " "1"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg1 = (Fl_Text_Editor *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Editor_add_key_binding" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Editor_add_key_binding" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[3], (void**)(&arg4), SWIGTYPE_p_f_int_p_Fl_Text_Editor__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Text_Editor_add_key_binding" "', argument " "4"" of type '" "Fl_Text_Editor::Key_Func""'"); 
    }
  }
  {
    try {
      (arg1)->add_key_binding(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_remove_key_binding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 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, "Fl_Text_Editor_remove_key_binding", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Editor_remove_key_binding" "', argument " "1"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg1 = (Fl_Text_Editor *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Editor_remove_key_binding" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Editor_remove_key_binding" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->remove_key_binding(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_remove_all_key_bindings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Editor_remove_all_key_bindings" "', argument " "1"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg1 = (Fl_Text_Editor *)(argp1);
  {
    try {
      (arg1)->remove_all_key_bindings(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_bound_key_function__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 0 ;
  int arg2 ;
  int arg3 ;
  Fl_Text_Editor::Key_Binding *arg4 = (Fl_Text_Editor::Key_Binding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Fl_Text_Editor::Key_Func result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Editor_bound_key_function" "', argument " "1"" of type '" "Fl_Text_Editor const *""'"); 
  }
  arg1 = (Fl_Text_Editor *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Editor_bound_key_function" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Editor_bound_key_function" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_Fl_Text_Editor__Key_Binding, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Text_Editor_bound_key_function" "', argument " "4"" of type '" "Fl_Text_Editor::Key_Binding *""'"); 
  }
  arg4 = (Fl_Text_Editor::Key_Binding *)(argp4);
  {
    try {
      result = (Fl_Text_Editor::Key_Func)((Fl_Text_Editor const *)arg1)->bound_key_function(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_int_p_Fl_Text_Editor__int);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_bound_key_function__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Fl_Text_Editor::Key_Func result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Editor_bound_key_function" "', argument " "1"" of type '" "Fl_Text_Editor const *""'"); 
  }
  arg1 = (Fl_Text_Editor *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Editor_bound_key_function" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Editor_bound_key_function" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (Fl_Text_Editor::Key_Func)((Fl_Text_Editor const *)arg1)->bound_key_function(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_int_p_Fl_Text_Editor__int);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_bound_key_function(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_bound_key_function", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Text_Editor_bound_key_function__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_Fl_Text_Editor_bound_key_function__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Text_Editor_bound_key_function'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Text_Editor::bound_key_function(int,int,Fl_Text_Editor::Key_Binding *) const\n"
    "    Fl_Text_Editor::bound_key_function(int,int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_default_key_function(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 0 ;
  Fl_Text_Editor::Key_Func arg2 = (Fl_Text_Editor::Key_Func) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_default_key_function", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Editor_default_key_function" "', argument " "1"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg1 = (Fl_Text_Editor *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_int_p_Fl_Text_Editor__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Text_Editor_default_key_function" "', argument " "2"" of type '" "Fl_Text_Editor::Key_Func""'"); 
    }
  }
  {
    try {
      (arg1)->default_key_function(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_default(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_default", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_default" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_default" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_default(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_ignore(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_ignore", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_ignore" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_ignore" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_ignore(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_backspace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_backspace", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_backspace" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_backspace" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_backspace(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_enter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_enter", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_enter" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_enter" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_enter(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_move(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_move", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_move" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_move" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_move(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_shift_move(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_shift_move", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_shift_move" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_shift_move" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_shift_move(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_ctrl_move(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_ctrl_move", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_ctrl_move" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_ctrl_move" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_ctrl_move(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_c_s_move(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_c_s_move", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_c_s_move" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_c_s_move" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_c_s_move(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_meta_move(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_meta_move", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_meta_move" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_meta_move" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_meta_move(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_m_s_move(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_m_s_move", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_m_s_move" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_m_s_move" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_m_s_move(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_home(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_home", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_home" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_home" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_home(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_end", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_end" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_end" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_end(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_left(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_left", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_left" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_left" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_left(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_up(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_up", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_up" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_up" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_up(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_right(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_right", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_right" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_right" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_right(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_down(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_down", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_down" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_down" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_down(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_page_up(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_page_up", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_page_up" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_page_up" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_page_up(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_page_down(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_page_down", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_page_down" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_page_down" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_page_down(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_insert", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_insert" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_insert" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_insert(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_delete(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_delete", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_delete" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_delete" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_delete(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_copy", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_copy" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_copy" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_copy(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_cut(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_cut", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_cut" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_cut" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_cut(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_paste(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_paste", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_paste" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_paste" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_paste(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_select_all(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_select_all", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_select_all" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_select_all" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_select_all(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_undo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_undo", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_undo" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_undo" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_undo(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_redo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Text_Editor *arg2 = (Fl_Text_Editor *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Text_Editor_kf_redo", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_redo" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_kf_redo" "', argument " "2"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg2 = (Fl_Text_Editor *)(argp2);
  {
    try {
      result = (int)Fl_Text_Editor::kf_redo(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 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, "Fl_Text_Editor_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Editor_init_type" "', argument " "1"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg1 = (Fl_Text_Editor *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Editor_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Text_Editor_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Text_Editor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Text_Editor" "', argument " "1"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg1 = (Fl_Text_Editor *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Text_Editor *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Text_Editor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Editor_draw" "', argument " "1"" of type '" "Fl_Text_Editor *""'"); 
  }
  arg1 = (Fl_Text_Editor *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Text_Editor *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Tile_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tile *arg1 = (Fl_Tile *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tile_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tile_handle" "', argument " "1"" of type '" "Fl_Tile *""'"); 
  }
  arg1 = (Fl_Tile *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tile_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Tile::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Tile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Tile *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Tile", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Tile" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Tile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Tile" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Tile" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Tile" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Tile *)new SwigDirector_Fl_Tile(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Tile *)new Fl_Tile(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tile, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Tile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tile *arg1 = (Fl_Tile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tile, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Tile" "', argument " "1"" of type '" "Fl_Tile *""'"); 
  }
  arg1 = (Fl_Tile *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tile_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tile *arg1 = (Fl_Tile *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tile_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tile_resize" "', argument " "1"" of type '" "Fl_Tile *""'"); 
  }
  arg1 = (Fl_Tile *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tile_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tile_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tile_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Tile_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Tile::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tile_move_intersection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tile *arg1 = (Fl_Tile *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tile_move_intersection", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tile_move_intersection" "', argument " "1"" of type '" "Fl_Tile *""'"); 
  }
  arg1 = (Fl_Tile *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tile_move_intersection" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tile_move_intersection" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tile_move_intersection" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Tile_move_intersection" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Tile::move_intersection(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->move_intersection(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tile_drag_intersection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tile *arg1 = (Fl_Tile *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tile_drag_intersection", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tile_drag_intersection" "', argument " "1"" of type '" "Fl_Tile *""'"); 
  }
  arg1 = (Fl_Tile *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tile_drag_intersection" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tile_drag_intersection" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tile_drag_intersection" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Tile_drag_intersection" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Tile::drag_intersection(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->drag_intersection(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tile_size_range__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tile *arg1 = (Fl_Tile *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 = (int) 0x7FFFFFFF ;
  int arg6 = (int) 0x7FFFFFFF ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tile_size_range" "', argument " "1"" of type '" "Fl_Tile *""'"); 
  }
  arg1 = (Fl_Tile *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tile_size_range" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tile_size_range" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tile_size_range" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Tile_size_range" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = (int)(val5);
  }
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Tile_size_range" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  {
    try {
      (arg1)->size_range(arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tile_size_range__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tile *arg1 = (Fl_Tile *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 = (int) 0x7FFFFFFF ;
  int arg6 = (int) 0x7FFFFFFF ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tile_size_range" "', argument " "1"" of type '" "Fl_Tile *""'"); 
  }
  arg1 = (Fl_Tile *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tile_size_range" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tile_size_range" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tile_size_range" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Tile_size_range" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = (int)(val5);
  }
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Tile_size_range" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  {
    try {
      (arg1)->size_range(arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tile_size_range(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tile_size_range", 0, 6, argv))) SWIG_fail;
  --argc;
  if ((argc >= 4) && (argc <= 6)) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Widget, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_Fl_Tile_size_range__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if ((argc >= 4) && (argc <= 6)) {
    PyObject *retobj = _wrap_Fl_Tile_size_range__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tile_size_range'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tile::size_range(int,int,int,int,int)\n"
    "    Fl_Tile::size_range(Fl_Widget *,int,int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tile_init_size_range(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tile *arg1 = (Fl_Tile *) 0 ;
  int arg2 = (int) -1 ;
  int arg3 = (int) -1 ;
  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, "Fl_Tile_init_size_range", 1, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tile_init_size_range" "', argument " "1"" of type '" "Fl_Tile *""'"); 
  }
  arg1 = (Fl_Tile *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tile_init_size_range" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tile_init_size_range" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      (arg1)->init_size_range(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tile_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tile *arg1 = (Fl_Tile *) 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, "Fl_Tile_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tile_init_type" "', argument " "1"" of type '" "Fl_Tile *""'"); 
  }
  arg1 = (Fl_Tile *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tile_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Tile_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Tile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tile *arg1 = (Fl_Tile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Tile" "', argument " "1"" of type '" "Fl_Tile *""'"); 
  }
  arg1 = (Fl_Tile *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tile_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tile *arg1 = (Fl_Tile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Tile *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tile_draw" "', argument " "1"" of type '" "Fl_Tile *""'"); 
  }
  arg1 = (Fl_Tile *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Tile *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Tiled_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  Fl_Image *arg2 = (Fl_Image *) 0 ;
  int arg3 = (int) 0 ;
  int arg4 = (int) 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Fl_Tiled_Image *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Tiled_Image", 2, 4, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_Tiled_Image" "', argument " "2"" of type '" "Fl_Image *""'"); 
  }
  arg2 = (Fl_Image *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Tiled_Image" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Tiled_Image" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Tiled_Image *)new SwigDirector_Fl_Tiled_Image(arg1,arg2,arg3,arg4); 
      } else {
        result = (Fl_Tiled_Image *)new Fl_Tiled_Image(arg2,arg3,arg4); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tiled_Image, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Tiled_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tiled_Image *arg1 = (Fl_Tiled_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tiled_Image, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Tiled_Image" "', argument " "1"" of type '" "Fl_Tiled_Image *""'"); 
  }
  arg1 = (Fl_Tiled_Image *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tiled_Image_copy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tiled_Image *arg1 = (Fl_Tiled_Image *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tiled_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tiled_Image_copy" "', argument " "1"" of type '" "Fl_Tiled_Image const *""'"); 
  }
  arg1 = (Fl_Tiled_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tiled_Image_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tiled_Image_copy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Fl_Image *)((Fl_Tiled_Image const *)arg1)->Fl_Tiled_Image::copy(arg2,arg3);
        } else {
          result = (Fl_Image *)((Fl_Tiled_Image const *)arg1)->copy(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, SWIG_POINTER_OWN |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tiled_Image_copy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tiled_Image *arg1 = (Fl_Tiled_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tiled_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tiled_Image_copy" "', argument " "1"" of type '" "Fl_Tiled_Image const *""'"); 
  }
  arg1 = (Fl_Tiled_Image *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Tiled_Image const *)arg1)->copy(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tiled_Image_copy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tiled_Image_copy", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tiled_Image_copy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Tiled_Image_copy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tiled_Image_copy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tiled_Image::copy(int,int) const\n"
    "    Fl_Tiled_Image::copy() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tiled_Image_color_average(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tiled_Image *arg1 = (Fl_Tiled_Image *) 0 ;
  Fl_Color arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tiled_Image_color_average", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tiled_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tiled_Image_color_average" "', argument " "1"" of type '" "Fl_Tiled_Image *""'"); 
  }
  arg1 = (Fl_Tiled_Image *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tiled_Image_color_average" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tiled_Image_color_average" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = (float)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Tiled_Image::color_average(arg2,arg3);
        } else {
          (arg1)->color_average(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tiled_Image_desaturate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tiled_Image *arg1 = (Fl_Tiled_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tiled_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tiled_Image_desaturate" "', argument " "1"" of type '" "Fl_Tiled_Image *""'"); 
  }
  arg1 = (Fl_Tiled_Image *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Tiled_Image::desaturate();
        } else {
          (arg1)->desaturate();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tiled_Image_draw__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tiled_Image *arg1 = (Fl_Tiled_Image *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 = (int) 0 ;
  int arg7 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tiled_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tiled_Image_draw" "', argument " "1"" of type '" "Fl_Tiled_Image *""'"); 
  }
  arg1 = (Fl_Tiled_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tiled_Image_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tiled_Image_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tiled_Image_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Tiled_Image_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Tiled_Image_draw" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = (int)(val6);
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Tiled_Image_draw" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Tiled_Image::draw(arg2,arg3,arg4,arg5,arg6,arg7);
        } else {
          (arg1)->draw(arg2,arg3,arg4,arg5,arg6,arg7);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tiled_Image_draw__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tiled_Image *arg1 = (Fl_Tiled_Image *) 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_Fl_Tiled_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tiled_Image_draw" "', argument " "1"" of type '" "Fl_Tiled_Image *""'"); 
  }
  arg1 = (Fl_Tiled_Image *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tiled_Image_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tiled_Image_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->draw(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tiled_Image_draw(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tiled_Image_draw", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Tiled_Image_draw__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 5) && (argc <= 7)) {
    PyObject *retobj = _wrap_Fl_Tiled_Image_draw__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tiled_Image_draw'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tiled_Image::draw(int,int,int,int,int,int)\n"
    "    Fl_Tiled_Image::draw(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tiled_Image_image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tiled_Image *arg1 = (Fl_Tiled_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tiled_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tiled_Image_image" "', argument " "1"" of type '" "Fl_Tiled_Image *""'"); 
  }
  arg1 = (Fl_Tiled_Image *)(argp1);
  {
    try {
      result = (Fl_Image *)(arg1)->image(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Tiled_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tiled_Image *arg1 = (Fl_Tiled_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tiled_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Tiled_Image" "', argument " "1"" of type '" "Fl_Tiled_Image *""'"); 
  }
  arg1 = (Fl_Tiled_Image *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Toggle_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Toggle_Button *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Toggle_Button", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Toggle_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Toggle_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Toggle_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Toggle_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Toggle_Button" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Toggle_Button *)new SwigDirector_Fl_Toggle_Button(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Toggle_Button *)new Fl_Toggle_Button(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Toggle_Button, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Toggle_Button_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Toggle_Button *arg1 = (Fl_Toggle_Button *) 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, "Fl_Toggle_Button_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Toggle_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Toggle_Button_init_type" "', argument " "1"" of type '" "Fl_Toggle_Button *""'"); 
  }
  arg1 = (Fl_Toggle_Button *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Toggle_Button_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Toggle_Button_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Toggle_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Toggle_Button *arg1 = (Fl_Toggle_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Toggle_Button, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Toggle_Button" "', argument " "1"" of type '" "Fl_Toggle_Button *""'"); 
  }
  arg1 = (Fl_Toggle_Button *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Toggle_Button(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Toggle_Button *arg1 = (Fl_Toggle_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Toggle_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Toggle_Button" "', argument " "1"" of type '" "Fl_Toggle_Button *""'"); 
  }
  arg1 = (Fl_Toggle_Button *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Toggle_Button_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Toggle_Button *arg1 = (Fl_Toggle_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Toggle_Button *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Toggle_Button, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Toggle_Button_draw" "', argument " "1"" of type '" "Fl_Toggle_Button *""'"); 
  }
  arg1 = (Fl_Toggle_Button *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Toggle_Button *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Tooltip_delay__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  float result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (float)Fl_Tooltip::delay(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_float((float)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_delay__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Tooltip_delay" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = (float)(val1);
  {
    try {
      Fl_Tooltip::delay(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_delay(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tooltip_delay", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_Fl_Tooltip_delay__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tooltip_delay__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tooltip_delay'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tooltip::delay()\n"
    "    Fl_Tooltip::delay(float)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_hidedelay__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  float result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (float)Fl_Tooltip::hidedelay(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_float((float)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_hidedelay__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Tooltip_hidedelay" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = (float)(val1);
  {
    try {
      Fl_Tooltip::hidedelay(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_hidedelay(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tooltip_hidedelay", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_Fl_Tooltip_hidedelay__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tooltip_hidedelay__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tooltip_hidedelay'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tooltip::hidedelay()\n"
    "    Fl_Tooltip::hidedelay(float)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_hoverdelay__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  float result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (float)Fl_Tooltip::hoverdelay(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_float((float)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_hoverdelay__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  float arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Tooltip_hoverdelay" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = (float)(val1);
  {
    try {
      Fl_Tooltip::hoverdelay(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_hoverdelay(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tooltip_hoverdelay", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_Fl_Tooltip_hoverdelay__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tooltip_hoverdelay__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tooltip_hoverdelay'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tooltip::hoverdelay()\n"
    "    Fl_Tooltip::hoverdelay(float)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_enabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tooltip_enabled", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)Fl_Tooltip::enabled(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_enable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 = (int) 1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tooltip_enable", 0, 1, swig_obj)) SWIG_fail;
  if (swig_obj[0]) {
    ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Tooltip_enable" "', argument " "1"" of type '" "int""'");
    } 
    arg1 = (int)(val1);
  }
  {
    try {
      Fl_Tooltip::enable(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_disable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tooltip_disable", 0, 0, 0)) SWIG_fail;
  {
    try {
      Fl_Tooltip::disable(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_enter_area(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tooltip_enter_area", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tooltip_enter_area" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tooltip_enter_area" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tooltip_enter_area" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tooltip_enter_area" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Tooltip_enter_area" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Fl_Tooltip_enter_area" "', argument " "6"" of type '" "char const *""'");
  }
  arg6 = (char *)(buf6);
  {
    try {
      Fl_Tooltip::enter_area(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_current__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Fl_Widget *)Fl_Tooltip::current(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Widget, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_current__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 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_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tooltip_current" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(argp1);
  {
    try {
      Fl_Tooltip::current(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_current(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tooltip_current", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_Fl_Tooltip_current__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tooltip_current__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tooltip_current'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tooltip::current()\n"
    "    Fl_Tooltip::current(Fl_Widget *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_font__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Fl_Font)Fl_Tooltip::font(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_font__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Font arg1 ;
  int val1 ;
  int ecode1 = 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 '" "Fl_Tooltip_font" "', argument " "1"" of type '" "Fl_Font""'");
  } 
  arg1 = (Fl_Font)(val1);
  {
    try {
      Fl_Tooltip::font(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_font(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tooltip_font", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_Fl_Tooltip_font__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tooltip_font__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tooltip_font'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tooltip::font()\n"
    "    Fl_Tooltip::font(Fl_Font)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Fl_Fontsize)Fl_Tooltip::size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Fontsize arg1 ;
  int val1 ;
  int ecode1 = 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 '" "Fl_Tooltip_size" "', argument " "1"" of type '" "Fl_Fontsize""'");
  } 
  arg1 = (Fl_Fontsize)(val1);
  {
    try {
      Fl_Tooltip::size(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tooltip_size", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_Fl_Tooltip_size__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tooltip_size__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tooltip_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tooltip::size()\n"
    "    Fl_Tooltip::size(Fl_Fontsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_color__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Fl_Color)Fl_Tooltip::color(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_color__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Tooltip_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  {
    try {
      Fl_Tooltip::color(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_color(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tooltip_color", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_Fl_Tooltip_color__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tooltip_color__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tooltip_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tooltip::color()\n"
    "    Fl_Tooltip::color(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_textcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Fl_Color)Fl_Tooltip::textcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_textcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Tooltip_textcolor" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = (Fl_Color)(val1);
  {
    try {
      Fl_Tooltip::textcolor(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_textcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tooltip_textcolor", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_Fl_Tooltip_textcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tooltip_textcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tooltip_textcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tooltip::textcolor()\n"
    "    Fl_Tooltip::textcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_margin_width__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)Fl_Tooltip::margin_width(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_margin_width__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 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 '" "Fl_Tooltip_margin_width" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      Fl_Tooltip::margin_width(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_margin_width(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tooltip_margin_width", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_Fl_Tooltip_margin_width__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tooltip_margin_width__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tooltip_margin_width'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tooltip::margin_width()\n"
    "    Fl_Tooltip::margin_width(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_margin_height__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)Fl_Tooltip::margin_height(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_margin_height__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 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 '" "Fl_Tooltip_margin_height" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      Fl_Tooltip::margin_height(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_margin_height(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tooltip_margin_height", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_Fl_Tooltip_margin_height__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tooltip_margin_height__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tooltip_margin_height'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tooltip::margin_height()\n"
    "    Fl_Tooltip::margin_height(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_wrap_width__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (int)Fl_Tooltip::wrap_width(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_wrap_width__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 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 '" "Fl_Tooltip_wrap_width" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      Fl_Tooltip::wrap_width(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_wrap_width(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tooltip_wrap_width", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_Fl_Tooltip_wrap_width__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tooltip_wrap_width__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tooltip_wrap_width'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tooltip::wrap_width()\n"
    "    Fl_Tooltip::wrap_width(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_current_window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swig::Director *director = 0;
  Fl_Window *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tooltip_current_window", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Window *)Fl_Tooltip::current_window(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_override_text(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tooltip_override_text" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (int)Fl_Tooltip::override_text((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Tooltip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tooltip *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Tooltip", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Tooltip *)new Fl_Tooltip(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tooltip, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Tooltip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tooltip *arg1 = (Fl_Tooltip *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tooltip, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Tooltip" "', argument " "1"" of type '" "Fl_Tooltip *""'"); 
  }
  arg1 = (Fl_Tooltip *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Value_Output_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Value_Output *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Output_draw" "', argument " "1"" of type '" "Fl_Value_Output *""'"); 
  }
  arg1 = (Fl_Value_Output *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Value_Output *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Value_Output_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Output_handle" "', argument " "1"" of type '" "Fl_Value_Output *""'"); 
  }
  arg1 = (Fl_Value_Output *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Output_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Value_Output::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Value_Output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Value_Output *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Value_Output", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Value_Output" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Value_Output" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Value_Output" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Value_Output" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Value_Output" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Value_Output *)new SwigDirector_Fl_Value_Output(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Value_Output *)new Fl_Value_Output(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Value_Output, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_soft__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 0 ;
  uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Output_soft" "', argument " "1"" of type '" "Fl_Value_Output *""'"); 
  }
  arg1 = (Fl_Value_Output *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Output_soft" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = (uchar)(val2);
  {
    try {
      (arg1)->soft(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_soft__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Output_soft" "', argument " "1"" of type '" "Fl_Value_Output const *""'"); 
  }
  arg1 = (Fl_Value_Output *)(argp1);
  {
    try {
      result = (uchar)((Fl_Value_Output const *)arg1)->soft(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_soft(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Value_Output_soft", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Value_Output_soft__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Value_Output_soft__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Value_Output_soft'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Value_Output::soft(uchar)\n"
    "    Fl_Value_Output::soft() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_textfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Output_textfont" "', argument " "1"" of type '" "Fl_Value_Output const *""'"); 
  }
  arg1 = (Fl_Value_Output *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Value_Output const *)arg1)->textfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_textfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 0 ;
  Fl_Font 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_Fl_Value_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Output_textfont" "', argument " "1"" of type '" "Fl_Value_Output *""'"); 
  }
  arg1 = (Fl_Value_Output *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Output_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->textfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_textfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Value_Output_textfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Value_Output_textfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Value_Output_textfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Value_Output_textfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Value_Output::textfont() const\n"
    "    Fl_Value_Output::textfont(Fl_Font)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_textsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Output_textsize" "', argument " "1"" of type '" "Fl_Value_Output const *""'"); 
  }
  arg1 = (Fl_Value_Output *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Value_Output const *)arg1)->textsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_textsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 0 ;
  Fl_Fontsize 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_Fl_Value_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Output_textsize" "', argument " "1"" of type '" "Fl_Value_Output *""'"); 
  }
  arg1 = (Fl_Value_Output *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Output_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->textsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_textsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Value_Output_textsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Value_Output_textsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Value_Output_textsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Value_Output_textsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Value_Output::textsize() const\n"
    "    Fl_Value_Output::textsize(Fl_Fontsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_textcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Output_textcolor" "', argument " "1"" of type '" "Fl_Value_Output const *""'"); 
  }
  arg1 = (Fl_Value_Output *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Value_Output const *)arg1)->textcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_textcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Output_textcolor" "', argument " "1"" of type '" "Fl_Value_Output *""'"); 
  }
  arg1 = (Fl_Value_Output *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Output_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->textcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_textcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Value_Output_textcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Value_Output_textcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Value_Output_textcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Value_Output_textcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Value_Output::textcolor() const\n"
    "    Fl_Value_Output::textcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 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, "Fl_Value_Output_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Value_Output_init_type" "', argument " "1"" of type '" "Fl_Value_Output *""'"); 
  }
  arg1 = (Fl_Value_Output *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Value_Output_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Value_Output_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Value_Output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Output, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Value_Output" "', argument " "1"" of type '" "Fl_Value_Output *""'"); 
  }
  arg1 = (Fl_Value_Output *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Value_Output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Value_Output, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Value_Output" "', argument " "1"" of type '" "Fl_Value_Output *""'"); 
  }
  arg1 = (Fl_Value_Output *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Wizard_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Wizard *arg1 = (Fl_Wizard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Wizard *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Wizard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Wizard_draw" "', argument " "1"" of type '" "Fl_Wizard *""'"); 
  }
  arg1 = (Fl_Wizard *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Wizard *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Wizard(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Wizard *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Wizard", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Wizard" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Wizard" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Wizard" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Wizard" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Wizard" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Wizard *)new SwigDirector_Fl_Wizard(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Wizard *)new Fl_Wizard(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Wizard, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Wizard_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Wizard *arg1 = (Fl_Wizard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Wizard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Wizard_next" "', argument " "1"" of type '" "Fl_Wizard *""'"); 
  }
  arg1 = (Fl_Wizard *)(argp1);
  {
    try {
      (arg1)->next(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Wizard_prev(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Wizard *arg1 = (Fl_Wizard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Wizard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Wizard_prev" "', argument " "1"" of type '" "Fl_Wizard *""'"); 
  }
  arg1 = (Fl_Wizard *)(argp1);
  {
    try {
      (arg1)->prev(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Wizard_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Wizard *arg1 = (Fl_Wizard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Wizard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Wizard_value" "', argument " "1"" of type '" "Fl_Wizard *""'"); 
  }
  arg1 = (Fl_Wizard *)(argp1);
  {
    try {
      result = (Fl_Widget *)(arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Widget, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Wizard_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Wizard *arg1 = (Fl_Wizard *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Wizard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Wizard_value" "', argument " "1"" of type '" "Fl_Wizard *""'"); 
  }
  arg1 = (Fl_Wizard *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Wizard_value" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  {
    try {
      (arg1)->value(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Wizard_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Wizard_value", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Wizard_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Wizard_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Wizard_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Wizard::value()\n"
    "    Fl_Wizard::value(Fl_Widget *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Wizard_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Wizard *arg1 = (Fl_Wizard *) 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, "Fl_Wizard_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Wizard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Wizard_init_type" "', argument " "1"" of type '" "Fl_Wizard *""'"); 
  }
  arg1 = (Fl_Wizard *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Wizard_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Wizard_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Wizard(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Wizard *arg1 = (Fl_Wizard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Wizard, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Wizard" "', argument " "1"" of type '" "Fl_Wizard *""'"); 
  }
  arg1 = (Fl_Wizard *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Wizard(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Wizard *arg1 = (Fl_Wizard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Wizard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Wizard" "', argument " "1"" of type '" "Fl_Wizard *""'"); 
  }
  arg1 = (Fl_Wizard *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_XBM_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Fl_XBM_Image *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_XBM_Image", 2, 2, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_XBM_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_XBM_Image *)new SwigDirector_Fl_XBM_Image(arg1,(char const *)arg2); 
      } else {
        result = (Fl_XBM_Image *)new Fl_XBM_Image((char const *)arg2); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_XBM_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_XBM_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_XBM_Image *arg1 = (Fl_XBM_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_XBM_Image, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_XBM_Image" "', argument " "1"" of type '" "Fl_XBM_Image *""'"); 
  }
  arg1 = (Fl_XBM_Image *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_XBM_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_XBM_Image *arg1 = (Fl_XBM_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_XBM_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_XBM_Image" "', argument " "1"" of type '" "Fl_XBM_Image *""'"); 
  }
  arg1 = (Fl_XBM_Image *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_XPM_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Fl_XPM_Image *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_XPM_Image", 2, 2, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_XPM_Image" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_XPM_Image *)new SwigDirector_Fl_XPM_Image(arg1,(char const *)arg2); 
      } else {
        result = (Fl_XPM_Image *)new Fl_XPM_Image((char const *)arg2); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_XPM_Image, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_XPM_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_XPM_Image *arg1 = (Fl_XPM_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_XPM_Image, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_XPM_Image" "', argument " "1"" of type '" "Fl_XPM_Image *""'"); 
  }
  arg1 = (Fl_XPM_Image *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_XPM_Image(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_XPM_Image *arg1 = (Fl_XPM_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_XPM_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_XPM_Image" "', argument " "1"" of type '" "Fl_XPM_Image *""'"); 
  }
  arg1 = (Fl_XPM_Image *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_X_flx(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_X *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_X_flx" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = (Fl_X *)Fl_X::flx((Fl_Window const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_X, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_X(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_X *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_X", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_X *)new Fl_X(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_X, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_X(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_X *arg1 = (Fl_X *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_X, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_X" "', argument " "1"" of type '" "Fl_X *""'"); 
  }
  arg1 = (Fl_X *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_fl_xid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Window result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_xid" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = (Fl_Window *)(argp1);
  {
    try {
      result = fl_xid((Fl_Window const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyLong_FromVoidPtr( (Fl_Window*)result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Window arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Window *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Window,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_find" "', argument " "1"" of type '" "Window""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fl_find" "', argument " "1"" of type '" "Window""'");
    } else {
      Window * temp = (Window *)(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      result = (Fl_Window *)fl_find(SWIG_STD_MOVE(arg1)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_open_display(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_open_display", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_open_display(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_close_display(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_close_display", 0, 0, 0)) SWIG_fail;
  {
    try {
      fl_close_display(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_parse_color(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  uchar *arg2 = 0 ;
  uchar *arg3 = 0 ;
  uchar *arg4 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  uchar temp2 ;
  int res2 = 0 ;
  uchar temp3 ;
  int res3 = 0 ;
  uchar temp4 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_parse_color", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_parse_color" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_unsigned_char,0))))) {
    unsigned char val;
    int ecode = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val);
    if (!SWIG_IsOK(ecode)) {
      SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "fl_parse_color" "', argument " "2"" of type '" "uchar""'");
    }
    temp2 = (uchar)(val);
    arg2 = &temp2;
    res2 = SWIG_AddTmpMask(ecode);
  }
  if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_unsigned_char,0))))) {
    unsigned char val;
    int ecode = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val);
    if (!SWIG_IsOK(ecode)) {
      SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "fl_parse_color" "', argument " "3"" of type '" "uchar""'");
    }
    temp3 = (uchar)(val);
    arg3 = &temp3;
    res3 = SWIG_AddTmpMask(ecode);
  }
  if (!(SWIG_IsOK((res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4),SWIGTYPE_p_unsigned_char,0))))) {
    unsigned char val;
    int ecode = SWIG_AsVal_unsigned_SS_char(swig_obj[3], &val);
    if (!SWIG_IsOK(ecode)) {
      SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "fl_parse_color" "', argument " "4"" of type '" "uchar""'");
    }
    temp4 = (uchar)(val);
    arg4 = &temp4;
    res4 = SWIG_AddTmpMask(ecode);
  }
  {
    try {
      result = (int)fl_parse_color((char const *)arg1,*arg2,*arg3,*arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags), 0);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_open_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void (*arg1)(char const *) = (void (*)(char const *)) 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "fl_open_callback" "', argument " "1"" of type '" "void (*)(char const *)""'"); 
    }
  }
  {
    try {
      fl_open_callback(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Tree_Prefs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Tree_Prefs", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Fl_Tree_Prefs *)new Fl_Tree_Prefs(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Prefs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Tree_Prefs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Tree_Prefs" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_item_labelfont" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Tree_Prefs const *)arg1)->item_labelfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Font 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_item_labelfont" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_item_labelfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->item_labelfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_item_labelfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_item_labelfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_item_labelfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_item_labelfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::item_labelfont() const\n"
    "    Fl_Tree_Prefs::item_labelfont(Fl_Font)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_item_labelsize" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Tree_Prefs const *)arg1)->item_labelsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Fontsize 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_item_labelsize" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_item_labelsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->item_labelsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_item_labelsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_item_labelsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_item_labelsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_item_labelsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::item_labelsize() const\n"
    "    Fl_Tree_Prefs::item_labelsize(Fl_Fontsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelfgcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_item_labelfgcolor" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Tree_Prefs const *)arg1)->item_labelfgcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelfgcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_item_labelfgcolor" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_item_labelfgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->item_labelfgcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelfgcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_item_labelfgcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_item_labelfgcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_item_labelfgcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_item_labelfgcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::item_labelfgcolor() const\n"
    "    Fl_Tree_Prefs::item_labelfgcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelbgcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_item_labelbgcolor" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Tree_Prefs const *)arg1)->item_labelbgcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelbgcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_item_labelbgcolor" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_item_labelbgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->item_labelbgcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelbgcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_item_labelbgcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_item_labelbgcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_item_labelbgcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_item_labelbgcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::item_labelbgcolor() const\n"
    "    Fl_Tree_Prefs::item_labelbgcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_labelfont" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Tree_Prefs const *)arg1)->labelfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Font 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_labelfont" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_labelfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->labelfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_labelfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_labelfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_labelfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_labelfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::labelfont() const\n"
    "    Fl_Tree_Prefs::labelfont(Fl_Font)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_labelsize" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Tree_Prefs const *)arg1)->labelsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Fontsize 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_labelsize" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_labelsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->labelsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_labelsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_labelsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_labelsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_labelsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::labelsize() const\n"
    "    Fl_Tree_Prefs::labelsize(Fl_Fontsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelfgcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_labelfgcolor" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Tree_Prefs const *)arg1)->labelfgcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelfgcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_labelfgcolor" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_labelfgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->labelfgcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelfgcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_labelfgcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_labelfgcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_labelfgcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_labelfgcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::labelfgcolor() const\n"
    "    Fl_Tree_Prefs::labelfgcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelbgcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_labelbgcolor" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Tree_Prefs const *)arg1)->labelbgcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelbgcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_labelbgcolor" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_labelbgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->labelbgcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelbgcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_labelbgcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_labelbgcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_labelbgcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_labelbgcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::labelbgcolor() const\n"
    "    Fl_Tree_Prefs::labelbgcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_marginleft__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_marginleft" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Prefs const *)arg1)->marginleft(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_marginleft__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_marginleft" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_marginleft" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->marginleft(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_marginleft(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_marginleft", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_marginleft__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_marginleft__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_marginleft'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::marginleft() const\n"
    "    Fl_Tree_Prefs::marginleft(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_margintop__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_margintop" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Prefs const *)arg1)->margintop(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_margintop__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_margintop" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_margintop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->margintop(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_margintop(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_margintop", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_margintop__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_margintop__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_margintop'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::margintop() const\n"
    "    Fl_Tree_Prefs::margintop(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_marginbottom__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_marginbottom" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Prefs const *)arg1)->marginbottom(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_marginbottom__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_marginbottom" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_marginbottom" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->marginbottom(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_marginbottom(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_marginbottom", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_marginbottom__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_marginbottom__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_marginbottom'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::marginbottom() const\n"
    "    Fl_Tree_Prefs::marginbottom(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_openchild_marginbottom__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_openchild_marginbottom" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Prefs const *)arg1)->openchild_marginbottom(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_openchild_marginbottom__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_openchild_marginbottom" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_openchild_marginbottom" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->openchild_marginbottom(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_openchild_marginbottom(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_openchild_marginbottom", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_openchild_marginbottom__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_openchild_marginbottom__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_openchild_marginbottom'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::openchild_marginbottom() const\n"
    "    Fl_Tree_Prefs::openchild_marginbottom(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_usericonmarginleft__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_usericonmarginleft" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Prefs const *)arg1)->usericonmarginleft(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_usericonmarginleft__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_usericonmarginleft" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_usericonmarginleft" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->usericonmarginleft(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_usericonmarginleft(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_usericonmarginleft", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_usericonmarginleft__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_usericonmarginleft__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_usericonmarginleft'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::usericonmarginleft() const\n"
    "    Fl_Tree_Prefs::usericonmarginleft(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelmarginleft__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_labelmarginleft" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Prefs const *)arg1)->labelmarginleft(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelmarginleft__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_labelmarginleft" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_labelmarginleft" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->labelmarginleft(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelmarginleft(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_labelmarginleft", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_labelmarginleft__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_labelmarginleft__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_labelmarginleft'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::labelmarginleft() const\n"
    "    Fl_Tree_Prefs::labelmarginleft(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_widgetmarginleft__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_widgetmarginleft" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Prefs const *)arg1)->widgetmarginleft(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_widgetmarginleft__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_widgetmarginleft" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_widgetmarginleft" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->widgetmarginleft(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_widgetmarginleft(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_widgetmarginleft", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_widgetmarginleft__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_widgetmarginleft__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_widgetmarginleft'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::widgetmarginleft() const\n"
    "    Fl_Tree_Prefs::widgetmarginleft(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_linespacing__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_linespacing" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Prefs const *)arg1)->linespacing(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_linespacing__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_linespacing" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_linespacing" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->linespacing(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_linespacing(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_linespacing", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_linespacing__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_linespacing__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_linespacing'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::linespacing() const\n"
    "    Fl_Tree_Prefs::linespacing(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_connectorcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_connectorcolor" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Tree_Prefs const *)arg1)->connectorcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_connectorcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_connectorcolor" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_connectorcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->connectorcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_connectorcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_connectorcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_connectorcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_connectorcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_connectorcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::connectorcolor() const\n"
    "    Fl_Tree_Prefs::connectorcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_connectorstyle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Tree_Connector result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_connectorstyle" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Tree_Connector)((Fl_Tree_Prefs const *)arg1)->connectorstyle(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_connectorstyle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Tree_Connector 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_connectorstyle" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_connectorstyle" "', argument " "2"" of type '" "Fl_Tree_Connector""'");
  } 
  arg2 = (Fl_Tree_Connector)(val2);
  {
    try {
      (arg1)->connectorstyle(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_connectorstyle__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_connectorstyle" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_connectorstyle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->connectorstyle(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_connectorstyle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_connectorstyle", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_connectorstyle__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_connectorstyle__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_connectorstyle__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_connectorstyle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::connectorstyle() const\n"
    "    Fl_Tree_Prefs::connectorstyle(Fl_Tree_Connector)\n"
    "    Fl_Tree_Prefs::connectorstyle(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_connectorwidth__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_connectorwidth" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Prefs const *)arg1)->connectorwidth(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_connectorwidth__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_connectorwidth" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_connectorwidth" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->connectorwidth(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_connectorwidth(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_connectorwidth", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_connectorwidth__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_connectorwidth__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_connectorwidth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::connectorwidth() const\n"
    "    Fl_Tree_Prefs::connectorwidth(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_openicon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_openicon" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Tree_Prefs const *)arg1)->openicon(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_openicon_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_openicon_w" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Prefs const *)arg1)->openicon_w(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_openicon_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_openicon_h" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Prefs const *)arg1)->openicon_h(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_openicon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Image *arg2 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_openicon" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Prefs_openicon" "', argument " "2"" of type '" "Fl_Image *""'"); 
  }
  arg2 = (Fl_Image *)(argp2);
  {
    try {
      (arg1)->openicon(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_openicon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_openicon", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_openicon__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_openicon__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_openicon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::openicon() const\n"
    "    Fl_Tree_Prefs::openicon(Fl_Image *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_closeicon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_closeicon" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Tree_Prefs const *)arg1)->closeicon(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_closeicon_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_closeicon_w" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Prefs const *)arg1)->closeicon_w(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_closeicon_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_closeicon_h" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Prefs const *)arg1)->closeicon_h(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_closeicon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Image *arg2 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_closeicon" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Prefs_closeicon" "', argument " "2"" of type '" "Fl_Image *""'"); 
  }
  arg2 = (Fl_Image *)(argp2);
  {
    try {
      (arg1)->closeicon(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_closeicon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_closeicon", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_closeicon__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_closeicon__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_closeicon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::closeicon() const\n"
    "    Fl_Tree_Prefs::closeicon(Fl_Image *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_usericon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_usericon" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Tree_Prefs const *)arg1)->usericon(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_usericon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Image *arg2 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_usericon" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Prefs_usericon" "', argument " "2"" of type '" "Fl_Image *""'"); 
  }
  arg2 = (Fl_Image *)(argp2);
  {
    try {
      (arg1)->usericon(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_usericon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_usericon", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_usericon__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_usericon__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_usericon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::usericon() const\n"
    "    Fl_Tree_Prefs::usericon(Fl_Image *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_opendeicon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_opendeicon" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Tree_Prefs const *)arg1)->opendeicon(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_closedeicon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_closedeicon" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Tree_Prefs const *)arg1)->closedeicon(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_userdeicon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_userdeicon" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Tree_Prefs const *)arg1)->userdeicon(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_showcollapse__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_showcollapse" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (char)((Fl_Tree_Prefs const *)arg1)->showcollapse(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new char(result)), SWIGTYPE_p_char, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_showcollapse__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_showcollapse" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_showcollapse" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->showcollapse(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_showcollapse(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_showcollapse", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_showcollapse__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_showcollapse__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_showcollapse'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::showcollapse() const\n"
    "    Fl_Tree_Prefs::showcollapse(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_sortorder__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Tree_Sort result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_sortorder" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Tree_Sort)((Fl_Tree_Prefs const *)arg1)->sortorder(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_sortorder__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Tree_Sort 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_sortorder" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_sortorder" "', argument " "2"" of type '" "Fl_Tree_Sort""'");
  } 
  arg2 = (Fl_Tree_Sort)(val2);
  {
    try {
      (arg1)->sortorder(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_sortorder(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_sortorder", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_sortorder__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_sortorder__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_sortorder'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::sortorder() const\n"
    "    Fl_Tree_Prefs::sortorder(Fl_Tree_Sort)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_selectbox__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Boxtype result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_selectbox" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Boxtype)((Fl_Tree_Prefs const *)arg1)->selectbox(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_selectbox__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Boxtype 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_selectbox" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_selectbox" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = (Fl_Boxtype)(val2);
  {
    try {
      (arg1)->selectbox(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_selectbox(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_selectbox", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_selectbox__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_selectbox__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_selectbox'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::selectbox() const\n"
    "    Fl_Tree_Prefs::selectbox(Fl_Boxtype)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_showroot__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_showroot" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Prefs const *)arg1)->showroot(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_showroot__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_showroot" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_showroot" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->showroot(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_showroot(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_showroot", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_showroot__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_showroot__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_showroot'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::showroot() const\n"
    "    Fl_Tree_Prefs::showroot(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_selectmode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Tree_Select result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_selectmode" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Tree_Select)((Fl_Tree_Prefs const *)arg1)->selectmode(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_selectmode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Tree_Select 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_selectmode" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_selectmode" "', argument " "2"" of type '" "Fl_Tree_Select""'");
  } 
  arg2 = (Fl_Tree_Select)(val2);
  {
    try {
      (arg1)->selectmode(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_selectmode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_selectmode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_selectmode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_selectmode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_selectmode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::selectmode() const\n"
    "    Fl_Tree_Prefs::selectmode(Fl_Tree_Select)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_reselect_mode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Tree_Item_Reselect_Mode result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_item_reselect_mode" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Tree_Item_Reselect_Mode)((Fl_Tree_Prefs const *)arg1)->item_reselect_mode(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_reselect_mode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Tree_Item_Reselect_Mode 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_item_reselect_mode" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_item_reselect_mode" "', argument " "2"" of type '" "Fl_Tree_Item_Reselect_Mode""'");
  } 
  arg2 = (Fl_Tree_Item_Reselect_Mode)(val2);
  {
    try {
      (arg1)->item_reselect_mode(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_reselect_mode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_item_reselect_mode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_item_reselect_mode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_item_reselect_mode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_item_reselect_mode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::item_reselect_mode() const\n"
    "    Fl_Tree_Prefs::item_reselect_mode(Fl_Tree_Item_Reselect_Mode)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_draw_mode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Tree_Item_Draw_Mode result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_item_draw_mode" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Tree_Item_Draw_Mode)((Fl_Tree_Prefs const *)arg1)->item_draw_mode(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_draw_mode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Tree_Item_Draw_Mode 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_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_item_draw_mode" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_item_draw_mode" "', argument " "2"" of type '" "Fl_Tree_Item_Draw_Mode""'");
  } 
  arg2 = (Fl_Tree_Item_Draw_Mode)(val2);
  {
    try {
      (arg1)->item_draw_mode(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_draw_mode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_item_draw_mode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_item_draw_mode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_item_draw_mode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_item_draw_mode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::item_draw_mode() const\n"
    "    Fl_Tree_Prefs::item_draw_mode(Fl_Tree_Item_Draw_Mode)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_draw_callback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Tree_Item_Draw_Callback *arg2 = (Fl_Tree_Item_Draw_Callback *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_item_draw_callback" "', argument " "1"" of type '" "Fl_Tree_Prefs *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_Fl_Tree_Item_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_Tree_Prefs_item_draw_callback" "', argument " "2"" of type '" "Fl_Tree_Item_Draw_Callback *""'"); 
    }
  }
  if (swig_obj[2]) {
    res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Tree_Prefs_item_draw_callback" "', argument " "3"" of type '" "void *""'"); 
    }
  }
  {
    try {
      (arg1)->item_draw_callback(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_draw_callback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Tree_Item_Draw_Callback *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_item_draw_callback" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (Fl_Tree_Item_Draw_Callback *)((Fl_Tree_Prefs const *)arg1)->item_draw_callback(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_Fl_Tree_Item_p_void__void);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_draw_callback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_item_draw_callback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_item_draw_callback__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 2) && (argc <= 3)) {
    PyObject *retobj = _wrap_Fl_Tree_Prefs_item_draw_callback__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Prefs_item_draw_callback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Prefs::item_draw_callback(Fl_Tree_Item_Draw_Callback *,void *)\n"
    "    Fl_Tree_Prefs::item_draw_callback() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_draw_user_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  void *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_item_draw_user_data" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  {
    try {
      result = (void *)((Fl_Tree_Prefs const *)arg1)->item_draw_user_data(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_do_item_draw_callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Prefs_do_item_draw_callback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Prefs_do_item_draw_callback" "', argument " "1"" of type '" "Fl_Tree_Prefs const *""'"); 
  }
  arg1 = (Fl_Tree_Prefs *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Prefs_do_item_draw_callback" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      ((Fl_Tree_Prefs const *)arg1)->do_item_draw_callback(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Tree_Item_Array__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 = (int) 10 ;
  int val1 ;
  int ecode1 = 0 ;
  Fl_Tree_Item_Array *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 1)) SWIG_fail;
  if (swig_obj[0]) {
    ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Fl_Tree_Item_Array" "', argument " "1"" of type '" "int""'");
    } 
    arg1 = (int)(val1);
  }
  {
    try {
      result = (Fl_Tree_Item_Array *)new Fl_Tree_Item_Array(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item_Array, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Tree_Item_Array(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item_Array *arg1 = (Fl_Tree_Item_Array *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item_Array, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Tree_Item_Array" "', argument " "1"" of type '" "Fl_Tree_Item_Array *""'"); 
  }
  arg1 = (Fl_Tree_Item_Array *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Tree_Item_Array__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item_Array *arg1 = (Fl_Tree_Item_Array *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Tree_Item_Array *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fl_Tree_Item_Array" "', argument " "1"" of type '" "Fl_Tree_Item_Array const *""'"); 
  }
  arg1 = (Fl_Tree_Item_Array *)(argp1);
  {
    try {
      result = (Fl_Tree_Item_Array *)new Fl_Tree_Item_Array((Fl_Tree_Item_Array const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item_Array, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Tree_Item_Array(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_Tree_Item_Array", 0, 1, argv))) SWIG_fail;
  --argc;
  if ((argc >= 0) && (argc <= 1)) {
    int _v = 0;
    if (argc > 0) {
      {
        {
          int res = SWIG_AsVal_int(argv[0], NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (!_v) goto check_1;
    }
    return _wrap_new_Fl_Tree_Item_Array__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_Fl_Tree_Item_Array__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_Tree_Item_Array'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item_Array::Fl_Tree_Item_Array(int)\n"
    "    Fl_Tree_Item_Array::Fl_Tree_Item_Array(Fl_Tree_Item_Array const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_total(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item_Array *arg1 = (Fl_Tree_Item_Array *) 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_Fl_Tree_Item_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_Array_total" "', argument " "1"" of type '" "Fl_Tree_Item_Array const *""'"); 
  }
  arg1 = (Fl_Tree_Item_Array *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item_Array const *)arg1)->total(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item_Array *arg1 = (Fl_Tree_Item_Array *) 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, "Fl_Tree_Item_Array_swap", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_Array_swap" "', argument " "1"" of type '" "Fl_Tree_Item_Array *""'"); 
  }
  arg1 = (Fl_Tree_Item_Array *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_Array_swap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_Item_Array_swap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->swap(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_move(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item_Array *arg1 = (Fl_Tree_Item_Array *) 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] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_Array_move", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_Array_move" "', argument " "1"" of type '" "Fl_Tree_Item_Array *""'"); 
  }
  arg1 = (Fl_Tree_Item_Array *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_Array_move" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_Item_Array_move" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)(arg1)->move(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_deparent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item_Array *arg1 = (Fl_Tree_Item_Array *) 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, "Fl_Tree_Item_Array_deparent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_Array_deparent" "', argument " "1"" of type '" "Fl_Tree_Item_Array *""'"); 
  }
  arg1 = (Fl_Tree_Item_Array *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_Array_deparent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)(arg1)->deparent(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_reparent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item_Array *arg1 = (Fl_Tree_Item_Array *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Item *arg3 = (Fl_Tree_Item *) 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_Array_reparent", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_Array_reparent" "', argument " "1"" of type '" "Fl_Tree_Item_Array *""'"); 
  }
  arg1 = (Fl_Tree_Item_Array *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_Array_reparent" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Tree_Item_Array_reparent" "', argument " "3"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg3 = (Fl_Tree_Item *)(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tree_Item_Array_reparent" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      result = (int)(arg1)->reparent(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item_Array *arg1 = (Fl_Tree_Item_Array *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_Array_clear" "', argument " "1"" of type '" "Fl_Tree_Item_Array *""'"); 
  }
  arg1 = (Fl_Tree_Item_Array *)(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_add(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item_Array *arg1 = (Fl_Tree_Item_Array *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_Array_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_Array_add" "', argument " "1"" of type '" "Fl_Tree_Item_Array *""'"); 
  }
  arg1 = (Fl_Tree_Item_Array *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_Array_add" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      (arg1)->add(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item_Array *arg1 = (Fl_Tree_Item_Array *) 0 ;
  int arg2 ;
  Fl_Tree_Item *arg3 = (Fl_Tree_Item *) 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, "Fl_Tree_Item_Array_insert", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_Array_insert" "', argument " "1"" of type '" "Fl_Tree_Item_Array *""'"); 
  }
  arg1 = (Fl_Tree_Item_Array *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_Array_insert" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Tree_Item_Array_insert" "', argument " "3"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg3 = (Fl_Tree_Item *)(argp3);
  {
    try {
      (arg1)->insert(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_replace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item_Array *arg1 = (Fl_Tree_Item_Array *) 0 ;
  int arg2 ;
  Fl_Tree_Item *arg3 = (Fl_Tree_Item *) 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, "Fl_Tree_Item_Array_replace", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_Array_replace" "', argument " "1"" of type '" "Fl_Tree_Item_Array *""'"); 
  }
  arg1 = (Fl_Tree_Item_Array *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_Array_replace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Tree_Item_Array_replace" "', argument " "3"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg3 = (Fl_Tree_Item *)(argp3);
  {
    try {
      (arg1)->replace(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_remove__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item_Array *arg1 = (Fl_Tree_Item_Array *) 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_Fl_Tree_Item_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_Array_remove" "', argument " "1"" of type '" "Fl_Tree_Item_Array *""'"); 
  }
  arg1 = (Fl_Tree_Item_Array *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_Array_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->remove(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_remove__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item_Array *arg1 = (Fl_Tree_Item_Array *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_Array_remove" "', argument " "1"" of type '" "Fl_Tree_Item_Array *""'"); 
  }
  arg1 = (Fl_Tree_Item_Array *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_Array_remove" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      result = (int)(arg1)->remove(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_Array_remove", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Tree_Item, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Tree_Item_Array_remove__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_Array_remove__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_Array_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item_Array::remove(int)\n"
    "    Fl_Tree_Item_Array::remove(Fl_Tree_Item *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_manage_item_destroy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item_Array *arg1 = (Fl_Tree_Item_Array *) 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_Fl_Tree_Item_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_Array_manage_item_destroy" "', argument " "1"" of type '" "Fl_Tree_Item_Array *""'"); 
  }
  arg1 = (Fl_Tree_Item_Array *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_Array_manage_item_destroy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->manage_item_destroy(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_manage_item_destroy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item_Array *arg1 = (Fl_Tree_Item_Array *) 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_Fl_Tree_Item_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_Array_manage_item_destroy" "', argument " "1"" of type '" "Fl_Tree_Item_Array const *""'"); 
  }
  arg1 = (Fl_Tree_Item_Array *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item_Array const *)arg1)->manage_item_destroy(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_manage_item_destroy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_Array_manage_item_destroy", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Item_Array_manage_item_destroy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_Array_manage_item_destroy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_Array_manage_item_destroy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item_Array::manage_item_destroy(int)\n"
    "    Fl_Tree_Item_Array::manage_item_destroy() const\n");
  return 0;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Tree_Item_draw_vertical_connector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  Fl_Tree_Prefs *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Tree_Item *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_draw_vertical_connector", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_draw_vertical_connector" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_draw_vertical_connector" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_Item_draw_vertical_connector" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tree_Item_draw_vertical_connector" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Fl_Tree_Prefs,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Fl_Tree_Item_draw_vertical_connector" "', argument " "5"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_Item_draw_vertical_connector" "', argument " "5"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg5 = (Fl_Tree_Prefs *)(argp5);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw_vertical_connector"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw_vertical_connector");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Tree_Item *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->draw_vertical_connectorSwigPublic(arg2,arg3,arg4,(Fl_Tree_Prefs const &)*arg5);
        } else {
          (darg)->draw_vertical_connector(arg2,arg3,arg4,(Fl_Tree_Prefs const &)*arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_draw_horizontal_connector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  Fl_Tree_Prefs *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Tree_Item *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_draw_horizontal_connector", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_draw_horizontal_connector" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_draw_horizontal_connector" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_Item_draw_horizontal_connector" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tree_Item_draw_horizontal_connector" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Fl_Tree_Prefs,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Fl_Tree_Item_draw_horizontal_connector" "', argument " "5"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_Item_draw_horizontal_connector" "', argument " "5"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg5 = (Fl_Tree_Prefs *)(argp5);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw_horizontal_connector"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw_horizontal_connector");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Tree_Item *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->draw_horizontal_connectorSwigPublic(arg2,arg3,arg4,(Fl_Tree_Prefs const &)*arg5);
        } else {
          (darg)->draw_horizontal_connector(arg2,arg3,arg4,(Fl_Tree_Prefs const &)*arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Tree_Item__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  Fl_Tree_Prefs *arg2 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Tree_Prefs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_Tree_Item" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_Fl_Tree_Item" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = (Fl_Tree_Prefs *)(argp2);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Tree_Item *)new SwigDirector_Fl_Tree_Item(arg1,(Fl_Tree_Prefs const &)*arg2); 
      } else {
        result = (Fl_Tree_Item *)new Fl_Tree_Item((Fl_Tree_Prefs const &)*arg2); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Tree_Item__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  Fl_Tree *arg2 = (Fl_Tree *) 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_Tree_Item" "', argument " "2"" of type '" "Fl_Tree *""'"); 
  }
  arg2 = (Fl_Tree *)(argp2);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Tree_Item *)new SwigDirector_Fl_Tree_Item(arg1,arg2); 
      } else {
        result = (Fl_Tree_Item *)new Fl_Tree_Item(arg2); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Tree_Item(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Tree_Item" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Tree_Item__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_Tree_Item" "', argument " "2"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Tree_Item *)new SwigDirector_Fl_Tree_Item(arg1,(Fl_Tree_Item const *)arg2); 
      } else {
        result = (Fl_Tree_Item *)new Fl_Tree_Item((Fl_Tree_Item const *)arg2); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Tree_Item(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fl_Tree_Item", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Fl_Tree_Prefs, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_Fl_Tree_Item__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Tree, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_Fl_Tree_Item__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Fl_Tree_Item__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fl_Tree_Item'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::Fl_Tree_Item(Fl_Tree_Prefs const &)\n"
    "    Fl_Tree_Item::Fl_Tree_Item(Fl_Tree *)\n"
    "    Fl_Tree_Item::Fl_Tree_Item(PyObject *,Fl_Tree_Item const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_x(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_x" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->x(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_y(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_y" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->y(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_w" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->w(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_h" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->h(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_label_x(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_label_x" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->label_x(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_label_y(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_label_y" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->label_y(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_label_w(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_label_w" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->label_w(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_label_h(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_label_h" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->label_h(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_draw_item_content(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_draw_item_content", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_draw_item_content" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_draw_item_content" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Tree_Item::draw_item_content(arg2);
        } else {
          result = (int)(arg1)->draw_item_content(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  int arg2 ;
  int *arg3 = 0 ;
  int arg4 ;
  Fl_Tree_Item *arg5 = (Fl_Tree_Item *) 0 ;
  int *arg6 = 0 ;
  int arg7 = (int) 1 ;
  int arg8 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int temp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int temp6 ;
  int res6 = SWIG_TMPOBJ ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject *swig_obj[7] ;
  
  arg6 = &temp6;
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_draw", 5, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_draw" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
    int val;
    int ecode = SWIG_AsVal_int(swig_obj[2], &val);
    if (!SWIG_IsOK(ecode)) {
      SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Fl_Tree_Item_draw" "', argument " "3"" of type '" "int""'");
    }
    temp3 = (int)(val);
    arg3 = &temp3;
    res3 = SWIG_AddTmpMask(ecode);
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tree_Item_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Fl_Tree_Item_draw" "', argument " "5"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg5 = (Fl_Tree_Item *)(argp5);
  if (swig_obj[5]) {
    ecode7 = SWIG_AsVal_int(swig_obj[5], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Tree_Item_draw" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = (int)(val7);
  }
  if (swig_obj[6]) {
    ecode8 = SWIG_AsVal_int(swig_obj[6], &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Fl_Tree_Item_draw" "', argument " "8"" of type '" "int""'");
    } 
    arg8 = (int)(val8);
  }
  {
    try {
      (arg1)->draw(arg2,*arg3,arg4,arg5,*arg6,arg7,arg8); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_show_self(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  char *arg2 = (char *) "" ;
  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, "Fl_Tree_Item_show_self", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_show_self" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  if (swig_obj[1]) {
    res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_show_self" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = (char *)(buf2);
  }
  {
    try {
      ((Fl_Tree_Item const *)arg1)->show_self((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_label__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_label" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_label" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->label((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_label__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_label" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (char *)((Fl_Tree_Item const *)arg1)->label(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_label(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_label", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Item_label__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_label__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_label'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::label(char const *)\n"
    "    Fl_Tree_Item::label() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Font 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_labelfont" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_labelfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->labelfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_labelfont" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Tree_Item const *)arg1)->labelfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_labelfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Item_labelfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_labelfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_labelfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::labelfont(Fl_Font)\n"
    "    Fl_Tree_Item::labelfont() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Fontsize 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_labelsize" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_labelsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->labelsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_labelsize" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Tree_Item const *)arg1)->labelsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_labelsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Item_labelsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_labelsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_labelsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::labelsize(Fl_Fontsize)\n"
    "    Fl_Tree_Item::labelsize() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelfgcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_labelfgcolor" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_labelfgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->labelfgcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelfgcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_labelfgcolor" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Tree_Item const *)arg1)->labelfgcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelfgcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_labelfgcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Item_labelfgcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_labelfgcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_labelfgcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::labelfgcolor(Fl_Color)\n"
    "    Fl_Tree_Item::labelfgcolor() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_labelcolor" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_labelcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->labelcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_labelcolor" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Tree_Item const *)arg1)->labelcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_labelcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Item_labelcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_labelcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_labelcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::labelcolor(Fl_Color)\n"
    "    Fl_Tree_Item::labelcolor() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelbgcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_labelbgcolor" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_labelbgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->labelbgcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelbgcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_labelbgcolor" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Tree_Item const *)arg1)->labelbgcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelbgcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_labelbgcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Item_labelbgcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_labelbgcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_labelbgcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::labelbgcolor(Fl_Color)\n"
    "    Fl_Tree_Item::labelbgcolor() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_widget__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_widget" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_widget" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  {
    try {
      (arg1)->widget(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_widget__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_widget" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (Fl_Widget *)((Fl_Tree_Item const *)arg1)->widget(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Widget, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_widget(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_widget", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Item_widget__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_widget__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_widget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::widget(Fl_Widget *)\n"
    "    Fl_Tree_Item::widget() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_children(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_children" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->children(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_child__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_child" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_child" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->child(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_child__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_child" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_child" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (Fl_Tree_Item *)((Fl_Tree_Item const *)arg1)->child(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_child(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_child", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_child__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_child__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_child'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::child(int)\n"
    "    Fl_Tree_Item::child(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_has_children(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_has_children" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->has_children(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_find_child__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  char *arg2 = (char *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_find_child" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_find_child" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)(arg1)->find_child((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_find_child__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_find_child" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_find_child" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      result = (int)(arg1)->find_child(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_find_child(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_find_child", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Tree_Item, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Tree_Item_find_child__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_find_child__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_find_child'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::find_child(char const *)\n"
    "    Fl_Tree_Item::find_child(Fl_Tree_Item *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_remove_child__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_remove_child" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_remove_child" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      result = (int)(arg1)->remove_child(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_remove_child__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  char *arg2 = (char *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_remove_child" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_remove_child" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)(arg1)->remove_child((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_remove_child(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_remove_child", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Tree_Item, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Tree_Item_remove_child__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_remove_child__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_remove_child'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::remove_child(Fl_Tree_Item *)\n"
    "    Fl_Tree_Item::remove_child(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_clear_children(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_clear_children" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      (arg1)->clear_children(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_swap_children__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_swap_children" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_swap_children" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_Item_swap_children" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->swap_children(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_swap_children__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Item *arg3 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_swap_children" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_swap_children" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Tree_Item_swap_children" "', argument " "3"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg3 = (Fl_Tree_Item *)(argp3);
  {
    try {
      result = (int)(arg1)->swap_children(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_swap_children(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_swap_children", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Tree_Item, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Fl_Tree_Item, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Tree_Item_swap_children__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Tree_Item_swap_children__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_swap_children'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::swap_children(int,int)\n"
    "    Fl_Tree_Item::swap_children(Fl_Tree_Item *,Fl_Tree_Item *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_find_child_item__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_find_child_item" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_find_child_item" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (Fl_Tree_Item *)((Fl_Tree_Item const *)arg1)->find_child_item((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_find_child_item__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_find_child_item" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_find_child_item" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->find_child_item((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_find_child_item__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_find_child_item" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    /* Check if it is a list */
    if (PyList_Check(swig_obj[1])) {
      Py_ssize_t size = PyList_Size(swig_obj[1]);
      int i = 0;
      arg2 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[1],i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg2[i] = PyString_AsString(PyList_GetItem(swig_obj[1],i));
          //arg2[i] = SWIG_Python_str_AsChar(PyList_GetItem(swig_obj[1],i));
          arg2[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(swig_obj[1],i)));
        }
        else {
          PyErr_SetString(PyExc_TypeError,"list must contain strings");
          free(arg2);
          return NULL;
        }
        
      }
      arg2[i] = NULL;
      
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  {
    try {
      result = (Fl_Tree_Item *)((Fl_Tree_Item const *)arg1)->find_child_item(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg2);
  }
  return resultobj;
fail:
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_find_child_item__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_find_child_item" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    /* Check if it is a list */
    if (PyList_Check(swig_obj[1])) {
      Py_ssize_t size = PyList_Size(swig_obj[1]);
      int i = 0;
      arg2 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[1],i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg2[i] = PyString_AsString(PyList_GetItem(swig_obj[1],i));
          //arg2[i] = SWIG_Python_str_AsChar(PyList_GetItem(swig_obj[1],i));
          arg2[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(swig_obj[1],i)));
        }
        else {
          PyErr_SetString(PyExc_TypeError,"list must contain strings");
          free(arg2);
          return NULL;
        }
        
      }
      arg2[i] = NULL;
      
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->find_child_item(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg2);
  }
  return resultobj;
fail:
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_find_child_item(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_find_child_item", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_char, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Tree_Item_find_child_item__SWIG_3(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_char, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_Fl_Tree_Item_find_child_item__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_find_child_item__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_find_child_item__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_find_child_item'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::find_child_item(char const *) const\n"
    "    Fl_Tree_Item::find_child_item(char const *)\n"
    "    Fl_Tree_Item::find_child_item(char **) const\n"
    "    Fl_Tree_Item::find_child_item(char **)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_find_item__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_find_item" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    /* Check if it is a list */
    if (PyList_Check(swig_obj[1])) {
      Py_ssize_t size = PyList_Size(swig_obj[1]);
      int i = 0;
      arg2 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[1],i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg2[i] = PyString_AsString(PyList_GetItem(swig_obj[1],i));
          //arg2[i] = SWIG_Python_str_AsChar(PyList_GetItem(swig_obj[1],i));
          arg2[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(swig_obj[1],i)));
        }
        else {
          PyErr_SetString(PyExc_TypeError,"list must contain strings");
          free(arg2);
          return NULL;
        }
        
      }
      arg2[i] = NULL;
      
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  {
    try {
      result = (Fl_Tree_Item *)((Fl_Tree_Item const *)arg1)->find_item(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg2);
  }
  return resultobj;
fail:
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_find_item__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_find_item" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    /* Check if it is a list */
    if (PyList_Check(swig_obj[1])) {
      Py_ssize_t size = PyList_Size(swig_obj[1]);
      int i = 0;
      arg2 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[1],i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg2[i] = PyString_AsString(PyList_GetItem(swig_obj[1],i));
          //arg2[i] = SWIG_Python_str_AsChar(PyList_GetItem(swig_obj[1],i));
          arg2[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(swig_obj[1],i)));
        }
        else {
          PyErr_SetString(PyExc_TypeError,"list must contain strings");
          free(arg2);
          return NULL;
        }
        
      }
      arg2[i] = NULL;
      
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->find_item(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg2);
  }
  return resultobj;
fail:
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_find_item(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_find_item", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_find_item__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_find_item__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_find_item'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::find_item(char **) const\n"
    "    Fl_Tree_Item::find_item(char **)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_add__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Prefs *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  Fl_Tree_Item *arg4 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_add" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Tree_Prefs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_add" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_Item_add" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = (Fl_Tree_Prefs *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Tree_Item_add" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Tree_Item_add" "', argument " "4"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg4 = (Fl_Tree_Item *)(argp4);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->add((Fl_Tree_Prefs const &)*arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_add__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Prefs *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_add" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Tree_Prefs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_add" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_Item_add" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = (Fl_Tree_Prefs *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Tree_Item_add" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->add((Fl_Tree_Prefs const &)*arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_add__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Prefs *arg2 = 0 ;
  char **arg3 = (char **) 0 ;
  Fl_Tree_Item *arg4 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_add" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Tree_Prefs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_add" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_Item_add" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = (Fl_Tree_Prefs *)(argp2);
  {
    /* Check if it is a list */
    if (PyList_Check(swig_obj[2])) {
      Py_ssize_t size = PyList_Size(swig_obj[2]);
      int i = 0;
      arg3 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[2],i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg3[i] = PyString_AsString(PyList_GetItem(swig_obj[2],i));
          //arg3[i] = SWIG_Python_str_AsChar(PyList_GetItem(swig_obj[2],i));
          arg3[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(swig_obj[2],i)));
        }
        else {
          PyErr_SetString(PyExc_TypeError,"list must contain strings");
          free(arg3);
          return NULL;
        }
        
      }
      arg3[i] = NULL;
      
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Tree_Item_add" "', argument " "4"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg4 = (Fl_Tree_Item *)(argp4);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->add((Fl_Tree_Prefs const &)*arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg3);
  }
  return resultobj;
fail:
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_add__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Prefs *arg2 = 0 ;
  char **arg3 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_add" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Tree_Prefs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_add" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_Item_add" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = (Fl_Tree_Prefs *)(argp2);
  {
    /* Check if it is a list */
    if (PyList_Check(swig_obj[2])) {
      Py_ssize_t size = PyList_Size(swig_obj[2]);
      int i = 0;
      arg3 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[2],i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg3[i] = PyString_AsString(PyList_GetItem(swig_obj[2],i));
          //arg3[i] = SWIG_Python_str_AsChar(PyList_GetItem(swig_obj[2],i));
          arg3[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(swig_obj[2],i)));
        }
        else {
          PyErr_SetString(PyExc_TypeError,"list must contain strings");
          free(arg3);
          return NULL;
        }
        
      }
      arg3[i] = NULL;
      
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->add((Fl_Tree_Prefs const &)*arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg3);
  }
  return resultobj;
fail:
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_add", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_p_char, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Tree_Item_add__SWIG_3(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Tree_Item_add__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_p_char, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_Fl_Tree_Item_add__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_Fl_Tree_Item_add__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::add(Fl_Tree_Prefs const &,char const *,Fl_Tree_Item *)\n"
    "    Fl_Tree_Item::add(Fl_Tree_Prefs const &,char const *)\n"
    "    Fl_Tree_Item::add(Fl_Tree_Prefs const &,char **,Fl_Tree_Item *)\n"
    "    Fl_Tree_Item::add(Fl_Tree_Prefs const &,char **)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_replace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_replace", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_replace" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_replace" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->replace(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_replace_child(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Item *arg3 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_replace_child", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_replace_child" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_replace_child" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Tree_Item_replace_child" "', argument " "3"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg3 = (Fl_Tree_Item *)(argp3);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->replace_child(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Prefs *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_insert", 3, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_insert" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Tree_Prefs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_insert" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_Item_insert" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = (Fl_Tree_Prefs *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Tree_Item_insert" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tree_Item_insert" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->insert((Fl_Tree_Prefs const &)*arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_insert_above(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Prefs *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_insert_above", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_insert_above" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Tree_Prefs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_insert_above" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_Item_insert_above" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = (Fl_Tree_Prefs *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Tree_Item_insert_above" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->insert_above((Fl_Tree_Prefs const &)*arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_deparent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_deparent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_deparent" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_deparent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->deparent(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_reparent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_reparent", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_reparent" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_reparent" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_Item_reparent" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)(arg1)->reparent(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_move__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_move" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_move" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_Item_move" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)(arg1)->move(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_move__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  int arg3 = (int) 0 ;
  int arg4 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_move" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_move" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_Item_move" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tree_Item_move" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  {
    try {
      result = (int)(arg1)->move(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_move(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_move", 0, 4, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 4)) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Tree_Item, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_Fl_Tree_Item_move__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Tree_Item_move__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_move'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::move(int,int)\n"
    "    Fl_Tree_Item::move(Fl_Tree_Item *,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_move_above(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 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, "Fl_Tree_Item_move_above", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_move_above" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_move_above" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      result = (int)(arg1)->move_above(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_move_below(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 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, "Fl_Tree_Item_move_below", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_move_below" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_move_below" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      result = (int)(arg1)->move_below(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_move_into(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  int arg3 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_move_into", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_move_into" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_move_into" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_Item_move_into" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->move_into(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_depth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_depth" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->depth(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_prev(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_prev" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->prev(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_next" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->next(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_next_sibling(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_next_sibling" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->next_sibling(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_prev_sibling(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_prev_sibling" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->prev_sibling(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_update_prev_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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, "Fl_Tree_Item_update_prev_next", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_update_prev_next" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_update_prev_next" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->update_prev_next(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_next_displayed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Prefs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_next_displayed", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_next_displayed" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Tree_Prefs,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_next_displayed" "', argument " "2"" of type '" "Fl_Tree_Prefs &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_Item_next_displayed" "', argument " "2"" of type '" "Fl_Tree_Prefs &""'"); 
  }
  arg2 = (Fl_Tree_Prefs *)(argp2);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->next_displayed(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_prev_displayed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Prefs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_prev_displayed", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_prev_displayed" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Tree_Prefs,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_prev_displayed" "', argument " "2"" of type '" "Fl_Tree_Prefs &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_Item_prev_displayed" "', argument " "2"" of type '" "Fl_Tree_Prefs &""'"); 
  }
  arg2 = (Fl_Tree_Prefs *)(argp2);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->prev_displayed(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_next_visible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Prefs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_next_visible", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_next_visible" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Tree_Prefs,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_next_visible" "', argument " "2"" of type '" "Fl_Tree_Prefs &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_Item_next_visible" "', argument " "2"" of type '" "Fl_Tree_Prefs &""'"); 
  }
  arg2 = (Fl_Tree_Prefs *)(argp2);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->next_visible(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_prev_visible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Prefs *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_prev_visible", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_prev_visible" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Tree_Prefs,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_prev_visible" "', argument " "2"" of type '" "Fl_Tree_Prefs &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_Item_prev_visible" "', argument " "2"" of type '" "Fl_Tree_Prefs &""'"); 
  }
  arg2 = (Fl_Tree_Prefs *)(argp2);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->prev_visible(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_parent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_parent" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->parent(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_parent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_parent" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (Fl_Tree_Item *)((Fl_Tree_Item const *)arg1)->parent(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_parent__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_parent" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_parent" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      (arg1)->parent(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_parent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_parent", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Item_parent__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Item_parent__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_parent__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_parent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::parent()\n"
    "    Fl_Tree_Item::parent() const\n"
    "    Fl_Tree_Item::parent(Fl_Tree_Item *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_prefs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Tree_Prefs *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_prefs" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (Fl_Tree_Prefs *) &((Fl_Tree_Item const *)arg1)->prefs(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_tree__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Tree *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_tree" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (Fl_Tree *)((Fl_Tree_Item const *)arg1)->tree(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_tree__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Tree *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_tree" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (Fl_Tree *)(arg1)->tree(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_tree(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_tree", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Item_tree__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Item_tree__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_tree'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::tree() const\n"
    "    Fl_Tree_Item::tree()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_open(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_open" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      (arg1)->open(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_close(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_close" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      (arg1)->close(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_is_open(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_is_open" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->is_open(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_is_close(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_is_close" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->is_close(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_open_toggle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_open_toggle" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      (arg1)->open_toggle(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_select(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  int arg2 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_select", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_select" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_select" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      (arg1)->select(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_select_toggle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_select_toggle" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      (arg1)->select_toggle(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_select_all(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_select_all" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)(arg1)->select_all(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_deselect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_deselect" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      (arg1)->deselect(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_deselect_all(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_deselect_all" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)(arg1)->deselect_all(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_is_selected(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_is_selected" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (char)((Fl_Tree_Item const *)arg1)->is_selected(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_activate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  int arg2 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_activate", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_activate" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_activate" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      (arg1)->activate(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_deactivate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_deactivate" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      (arg1)->deactivate(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_is_activated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_is_activated" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (char)((Fl_Tree_Item const *)arg1)->is_activated(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_is_active(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_is_active" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (char)((Fl_Tree_Item const *)arg1)->is_active(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_visible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_visible" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->visible(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_is_visible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_is_visible" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->is_visible(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_visible_r(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_visible_r" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->visible_r(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_is_visible_r(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_is_visible_r" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->is_visible_r(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_usericon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Image *arg2 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_usericon" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_usericon" "', argument " "2"" of type '" "Fl_Image *""'"); 
  }
  arg2 = (Fl_Image *)(argp2);
  {
    try {
      (arg1)->usericon(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_usericon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_usericon" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Tree_Item const *)arg1)->usericon(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_usericon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_usericon", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Item_usericon__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_usericon__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_usericon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::usericon(Fl_Image *)\n"
    "    Fl_Tree_Item::usericon() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_userdeicon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Image *arg2 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_userdeicon" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_userdeicon" "', argument " "2"" of type '" "Fl_Image *""'"); 
  }
  arg2 = (Fl_Image *)(argp2);
  {
    try {
      (arg1)->userdeicon(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_userdeicon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_userdeicon" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Tree_Item const *)arg1)->userdeicon(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_userdeicon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_userdeicon", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Item_userdeicon__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_userdeicon__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_userdeicon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::userdeicon(Fl_Image *)\n"
    "    Fl_Tree_Item::userdeicon() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_find_clicked__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Prefs *arg2 = 0 ;
  int arg3 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_find_clicked" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Tree_Prefs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_find_clicked" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_Item_find_clicked" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = (Fl_Tree_Prefs *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_Item_find_clicked" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (Fl_Tree_Item *)((Fl_Tree_Item const *)arg1)->find_clicked((Fl_Tree_Prefs const &)*arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_find_clicked__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Prefs *arg2 = 0 ;
  int arg3 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_find_clicked" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Tree_Prefs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_find_clicked" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_Item_find_clicked" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = (Fl_Tree_Prefs *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_Item_find_clicked" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->find_clicked((Fl_Tree_Prefs const &)*arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_find_clicked(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_find_clicked", 0, 3, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    PyObject *retobj = _wrap_Fl_Tree_Item_find_clicked__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 2) && (argc <= 3)) {
    PyObject *retobj = _wrap_Fl_Tree_Item_find_clicked__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_find_clicked'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::find_clicked(Fl_Tree_Prefs const &,int) const\n"
    "    Fl_Tree_Item::find_clicked(Fl_Tree_Prefs const &,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_event_on_item(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Prefs *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, "Fl_Tree_Item_event_on_item", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_event_on_item" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Tree_Prefs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_event_on_item" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_Item_event_on_item" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = (Fl_Tree_Prefs *)(argp2);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->event_on_item((Fl_Tree_Prefs const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_event_on_collapse_icon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Prefs *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, "Fl_Tree_Item_event_on_collapse_icon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_event_on_collapse_icon" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Tree_Prefs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_event_on_collapse_icon" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_Item_event_on_collapse_icon" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = (Fl_Tree_Prefs *)(argp2);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->event_on_collapse_icon((Fl_Tree_Prefs const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_event_on_user_icon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Prefs *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, "Fl_Tree_Item_event_on_user_icon", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_event_on_user_icon" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Tree_Prefs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_event_on_user_icon" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_Item_event_on_user_icon" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = (Fl_Tree_Prefs *)(argp2);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->event_on_user_icon((Fl_Tree_Prefs const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_event_on_label(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Prefs *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, "Fl_Tree_Item_event_on_label", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_event_on_label" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Tree_Prefs,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_event_on_label" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_Item_event_on_label" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = (Fl_Tree_Prefs *)(argp2);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->event_on_label((Fl_Tree_Prefs const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_is_root(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_is_root" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (int)((Fl_Tree_Item const *)arg1)->is_root(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 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, "Fl_Tree_Item_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_init_type" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Tree_Item_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_user_data__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  PyObject *arg2 = (PyObject *) 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_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_user_data" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  arg2 = swig_obj[1];
  {
    try {
      Fl_Tree_Item_user_data__SWIG_0(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_user_data__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_Item_user_data" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    try {
      result = (PyObject *)Fl_Tree_Item_user_data__SWIG_1(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_user_data(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_Item_user_data", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_Item_user_data__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_Item_user_data__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_Item_user_data'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree_Item::user_data(PyObject *)\n"
    "    Fl_Tree_Item::user_data()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Tree_Item(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Tree_Item" "', argument " "1"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg1 = (Fl_Tree_Item *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Fl_Tree_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Tree *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_draw" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Tree *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Tree(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[6] ;
  Fl_Tree *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_Tree", 5, 6, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Tree" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Tree" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Tree" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Tree" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Fl_Tree" "', argument " "6"" of type '" "char const *""'");
    }
    arg6 = (char *)(buf6);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Tree *)new SwigDirector_Fl_Tree(arg1,arg2,arg3,arg4,arg5,(char const *)arg6); 
      } else {
        result = (Fl_Tree *)new Fl_Tree(arg2,arg3,arg4,arg5,(char const *)arg6); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Tree(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Tree" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_handle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_handle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_handle" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Tree::handle(arg2);
        } else {
          result = (int)(arg1)->handle(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_show_self(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_show_self" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      (arg1)->show_self(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_resize" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tree_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Tree_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Tree::resize(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_root_label(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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, "Fl_Tree_root_label", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_root_label" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_root_label" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      (arg1)->root_label((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_root__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_root" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->root(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_root__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_root" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_root" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      (arg1)->root(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_root(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_root", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_root__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_root__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_root'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::root()\n"
    "    Fl_Tree::root(Fl_Tree_Item *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_prefs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Fl_Tree_Prefs *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_prefs" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Tree_Prefs *) &((Fl_Tree const *)arg1)->prefs(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Prefs, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_add__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  char *arg2 = (char *) 0 ;
  Fl_Tree_Item *arg3 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_add" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_add" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Tree_add" "', argument " "3"" of type '" "Fl_Tree_Item *""'"); 
    }
    arg3 = (Fl_Tree_Item *)(argp3);
  }
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->add((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_add__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_add" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_add" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Tree_add" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->add(arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_add", 0, 3, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    if (argc > 2) {
      {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Fl_Tree_Item, 0);
        _v = SWIG_CheckState(res);
      }
      if (!_v) goto check_1;
    }
    return _wrap_Fl_Tree_add__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Tree_add__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::add(char const *,Fl_Tree_Item *)\n"
    "    Fl_Tree::add(Fl_Tree_Item *,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_insert_above(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_insert_above", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_insert_above" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_insert_above" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Tree_insert_above" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->insert_above(arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_insert", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_insert" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_insert" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Tree_insert" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tree_insert" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->insert(arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 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, "Fl_Tree_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_remove" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_remove" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      result = (int)(arg1)->remove(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_clear" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_clear_children(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_clear_children", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_clear_children" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_clear_children" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      (arg1)->clear_children(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_find_item__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_find_item" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_find_item" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->find_item((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_find_item__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_find_item" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_find_item" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (Fl_Tree_Item *)((Fl_Tree const *)arg1)->find_item((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_find_item(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_find_item", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_find_item__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_find_item__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_find_item'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::find_item(char const *)\n"
    "    Fl_Tree::find_item(char const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_pathname(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  Fl_Tree_Item *arg4 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_item_pathname", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_item_pathname" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_item_pathname" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_item_pathname" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Tree_item_pathname" "', argument " "4"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg4 = (Fl_Tree_Item *)(argp4);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->item_pathname(arg2,arg3,(Fl_Tree_Item const *)arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_find_clicked__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  int arg2 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_find_clicked" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_find_clicked" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      result = (Fl_Tree_Item *)((Fl_Tree const *)arg1)->find_clicked(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_find_clicked__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  int arg2 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_find_clicked" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_find_clicked" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->find_clicked(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_find_clicked(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_find_clicked", 0, 2, argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    PyObject *retobj = _wrap_Fl_Tree_find_clicked__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if ((argc >= 1) && (argc <= 2)) {
    PyObject *retobj = _wrap_Fl_Tree_find_clicked__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_find_clicked'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::find_clicked(int) const\n"
    "    Fl_Tree::find_clicked(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_clicked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_item_clicked" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->item_clicked(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_first(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_first" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->first(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_first_visible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_first_visible" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->first_visible(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_first_visible_item(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_first_visible_item" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->first_visible_item(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_next", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_next" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_next" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
    }
    arg2 = (Fl_Tree_Item *)(argp2);
  }
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->next(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_prev(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_prev", 1, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_prev" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_prev" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
    }
    arg2 = (Fl_Tree_Item *)(argp2);
  }
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->prev(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_last(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_last" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->last(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_last_visible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_last_visible" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->last_visible(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_last_visible_item(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_last_visible_item" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->last_visible_item(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_next_visible_item(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_next_visible_item", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_next_visible_item" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_next_visible_item" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_next_visible_item" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->next_visible_item(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_first_selected_item(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_first_selected_item" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->first_selected_item(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_last_selected_item(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_last_selected_item" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->last_selected_item(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_next_item(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  int arg3 = (int) 0xff54 ;
  bool arg4 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_next_item", 2, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_next_item" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_next_item" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_next_item" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tree_next_item" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = (bool)(val4);
  }
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->next_item(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_next_selected_item(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  int arg3 = (int) 0xff54 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_next_selected_item", 1, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_next_selected_item" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_next_selected_item" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
    }
    arg2 = (Fl_Tree_Item *)(argp2);
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_next_selected_item" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->next_selected_item(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_get_selected_items(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item_Array *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, "Fl_Tree_get_selected_items", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_get_selected_items" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Tree_Item_Array,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_get_selected_items" "', argument " "2"" of type '" "Fl_Tree_Item_Array &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_get_selected_items" "', argument " "2"" of type '" "Fl_Tree_Item_Array &""'"); 
  }
  arg2 = (Fl_Tree_Item_Array *)(argp2);
  {
    try {
      result = (int)(arg1)->get_selected_items(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_open__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  int arg3 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_open" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_open" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_open" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->open(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_open__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 = (int) 1 ;
  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 < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_open" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_open" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_open" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->open((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_open(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_open", 0, 3, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Tree_Item, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_Fl_Tree_open__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if ((argc >= 2) && (argc <= 3)) {
    PyObject *retobj = _wrap_Fl_Tree_open__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_open'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::open(Fl_Tree_Item *,int)\n"
    "    Fl_Tree::open(char const *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_open_toggle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  int arg3 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_open_toggle", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_open_toggle" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_open_toggle" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_open_toggle" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      (arg1)->open_toggle(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_close__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  int arg3 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_close" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_close" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_close" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->close(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_close__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 = (int) 1 ;
  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 < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_close" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_close" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_close" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->close((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_close(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_close", 0, 3, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Tree_Item, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_Fl_Tree_close__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if ((argc >= 2) && (argc <= 3)) {
    PyObject *retobj = _wrap_Fl_Tree_close__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_close'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::close(Fl_Tree_Item *,int)\n"
    "    Fl_Tree::close(char const *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_is_open__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_is_open" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_is_open" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->is_open(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_is_open__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  char *arg2 = (char *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_is_open" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_is_open" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->is_open((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_is_open(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_is_open", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Tree_Item, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Tree_is_open__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_is_open__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_is_open'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::is_open(Fl_Tree_Item *) const\n"
    "    Fl_Tree::is_open(char const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_is_close__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_is_close" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_is_close" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->is_close(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_is_close__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  char *arg2 = (char *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_is_close" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_is_close" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->is_close((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_is_close(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_is_close", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Tree_Item, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Tree_is_close__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_is_close__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_is_close'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::is_close(Fl_Tree_Item *) const\n"
    "    Fl_Tree::is_close(char const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_select__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  int arg3 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_select" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_select" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_select" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->select(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_select__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 = (int) 1 ;
  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 < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_select" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_select" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_select" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->select((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_select(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_select", 0, 3, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Tree_Item, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_Fl_Tree_select__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if ((argc >= 2) && (argc <= 3)) {
    PyObject *retobj = _wrap_Fl_Tree_select__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_select'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::select(Fl_Tree_Item *,int)\n"
    "    Fl_Tree::select(char const *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_select_toggle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  int arg3 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_select_toggle", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_select_toggle" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_select_toggle" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_select_toggle" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      (arg1)->select_toggle(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_deselect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  int arg3 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_deselect" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_deselect" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_deselect" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->deselect(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_deselect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 = (int) 1 ;
  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 < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_deselect" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_deselect" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_deselect" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->deselect((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_deselect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_deselect", 0, 3, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Tree_Item, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_Fl_Tree_deselect__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if ((argc >= 2) && (argc <= 3)) {
    PyObject *retobj = _wrap_Fl_Tree_deselect__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_deselect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::deselect(Fl_Tree_Item *,int)\n"
    "    Fl_Tree::deselect(char const *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_deselect_all(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  int arg3 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_deselect_all", 1, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_deselect_all" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_deselect_all" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
    }
    arg2 = (Fl_Tree_Item *)(argp2);
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_deselect_all" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->deselect_all(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_select_only(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  int arg3 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_select_only", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_select_only" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_select_only" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_select_only" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->select_only(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_select_all(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  int arg3 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_select_all", 1, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_select_all" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_select_all" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
    }
    arg2 = (Fl_Tree_Item *)(argp2);
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_select_all" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  {
    try {
      result = (int)(arg1)->select_all(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_extend_selection_dir(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Item *arg3 = (Fl_Tree_Item *) 0 ;
  int arg4 ;
  int arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_extend_selection_dir", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_extend_selection_dir" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_extend_selection_dir" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Tree_extend_selection_dir" "', argument " "3"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg3 = (Fl_Tree_Item *)(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tree_extend_selection_dir" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Tree_extend_selection_dir" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Tree_extend_selection_dir" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = (bool)(val6);
  {
    try {
      result = (int)(arg1)->extend_selection_dir(arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_extend_selection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Item *arg3 = (Fl_Tree_Item *) 0 ;
  int arg4 = (int) 1 ;
  bool arg5 = (bool) false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_extend_selection", 3, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_extend_selection" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_extend_selection" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Tree_extend_selection" "', argument " "3"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg3 = (Fl_Tree_Item *)(argp3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tree_extend_selection" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Tree_extend_selection" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = (bool)(val5);
  }
  {
    try {
      result = (int)(arg1)->extend_selection(arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_set_item_focus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_set_item_focus", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_set_item_focus" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_set_item_focus" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      (arg1)->set_item_focus(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_get_item_focus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_get_item_focus" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Tree_Item *)((Fl_Tree const *)arg1)->get_item_focus(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_is_selected__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_is_selected" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_is_selected" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->is_selected(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_is_selected__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  char *arg2 = (char *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_is_selected" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_is_selected" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)(arg1)->is_selected((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_is_selected(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_is_selected", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Fl_Tree_Item, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_Tree_is_selected__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_is_selected__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_is_selected'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::is_selected(Fl_Tree_Item *) const\n"
    "    Fl_Tree::is_selected(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelfont__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_item_labelfont" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Font)((Fl_Tree const *)arg1)->item_labelfont(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelfont__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Font 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_item_labelfont" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_item_labelfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = (Fl_Font)(val2);
  {
    try {
      (arg1)->item_labelfont(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelfont(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_item_labelfont", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_item_labelfont__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_item_labelfont__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_item_labelfont'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::item_labelfont() const\n"
    "    Fl_Tree::item_labelfont(Fl_Font)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelsize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Fontsize result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_item_labelsize" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Fontsize)((Fl_Tree const *)arg1)->item_labelsize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelsize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Fontsize 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_item_labelsize" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_item_labelsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = (Fl_Fontsize)(val2);
  {
    try {
      (arg1)->item_labelsize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelsize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_item_labelsize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_item_labelsize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_item_labelsize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_item_labelsize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::item_labelsize() const\n"
    "    Fl_Tree::item_labelsize(Fl_Fontsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelfgcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_item_labelfgcolor" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Tree const *)arg1)->item_labelfgcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelfgcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_item_labelfgcolor" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_item_labelfgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->item_labelfgcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelfgcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_item_labelfgcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_item_labelfgcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_item_labelfgcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_item_labelfgcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::item_labelfgcolor() const\n"
    "    Fl_Tree::item_labelfgcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelbgcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_item_labelbgcolor" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Tree const *)arg1)->item_labelbgcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelbgcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_item_labelbgcolor" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_item_labelbgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->item_labelbgcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelbgcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_item_labelbgcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_item_labelbgcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_item_labelbgcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_item_labelbgcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::item_labelbgcolor() const\n"
    "    Fl_Tree::item_labelbgcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_connectorcolor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Color result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_connectorcolor" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Color)((Fl_Tree const *)arg1)->connectorcolor(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_connectorcolor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_connectorcolor" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_connectorcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = (Fl_Color)(val2);
  {
    try {
      (arg1)->connectorcolor(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_connectorcolor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_connectorcolor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_connectorcolor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_connectorcolor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_connectorcolor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::connectorcolor() const\n"
    "    Fl_Tree::connectorcolor(Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_marginleft__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_marginleft" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->marginleft(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_marginleft__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_marginleft" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_marginleft" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->marginleft(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_marginleft(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_marginleft", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_marginleft__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_marginleft__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_marginleft'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::marginleft() const\n"
    "    Fl_Tree::marginleft(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_margintop__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_margintop" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->margintop(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_margintop__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_margintop" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_margintop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->margintop(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_margintop(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_margintop", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_margintop__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_margintop__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_margintop'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::margintop() const\n"
    "    Fl_Tree::margintop(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_marginbottom__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_marginbottom" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->marginbottom(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_marginbottom__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_marginbottom" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_marginbottom" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->marginbottom(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_marginbottom(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_marginbottom", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_marginbottom__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_marginbottom__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_marginbottom'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::marginbottom() const\n"
    "    Fl_Tree::marginbottom(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_linespacing__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_linespacing" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->linespacing(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_linespacing__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_linespacing" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_linespacing" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->linespacing(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_linespacing(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_linespacing", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_linespacing__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_linespacing__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_linespacing'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::linespacing() const\n"
    "    Fl_Tree::linespacing(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_openchild_marginbottom__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_openchild_marginbottom" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->openchild_marginbottom(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_openchild_marginbottom__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_openchild_marginbottom" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_openchild_marginbottom" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->openchild_marginbottom(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_openchild_marginbottom(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_openchild_marginbottom", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_openchild_marginbottom__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_openchild_marginbottom__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_openchild_marginbottom'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::openchild_marginbottom() const\n"
    "    Fl_Tree::openchild_marginbottom(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_usericonmarginleft__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_usericonmarginleft" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->usericonmarginleft(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_usericonmarginleft__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_usericonmarginleft" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_usericonmarginleft" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->usericonmarginleft(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_usericonmarginleft(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_usericonmarginleft", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_usericonmarginleft__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_usericonmarginleft__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_usericonmarginleft'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::usericonmarginleft() const\n"
    "    Fl_Tree::usericonmarginleft(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_labelmarginleft__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_labelmarginleft" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->labelmarginleft(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_labelmarginleft__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_labelmarginleft" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_labelmarginleft" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->labelmarginleft(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_labelmarginleft(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_labelmarginleft", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_labelmarginleft__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_labelmarginleft__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_labelmarginleft'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::labelmarginleft() const\n"
    "    Fl_Tree::labelmarginleft(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_widgetmarginleft__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_widgetmarginleft" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->widgetmarginleft(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_widgetmarginleft__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_widgetmarginleft" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_widgetmarginleft" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->widgetmarginleft(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_widgetmarginleft(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_widgetmarginleft", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_widgetmarginleft__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_widgetmarginleft__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_widgetmarginleft'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::widgetmarginleft() const\n"
    "    Fl_Tree::widgetmarginleft(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_connectorwidth__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_connectorwidth" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->connectorwidth(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_connectorwidth__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_connectorwidth" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_connectorwidth" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->connectorwidth(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_connectorwidth(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_connectorwidth", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_connectorwidth__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_connectorwidth__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_connectorwidth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::connectorwidth() const\n"
    "    Fl_Tree::connectorwidth(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_usericon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_usericon" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Tree const *)arg1)->usericon(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_usericon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Image *arg2 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_usericon" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_usericon" "', argument " "2"" of type '" "Fl_Image *""'"); 
  }
  arg2 = (Fl_Image *)(argp2);
  {
    try {
      (arg1)->usericon(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_usericon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_usericon", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_usericon__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_usericon__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_usericon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::usericon() const\n"
    "    Fl_Tree::usericon(Fl_Image *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_openicon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_openicon" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Tree const *)arg1)->openicon(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_openicon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Image *arg2 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_openicon" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_openicon" "', argument " "2"" of type '" "Fl_Image *""'"); 
  }
  arg2 = (Fl_Image *)(argp2);
  {
    try {
      (arg1)->openicon(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_openicon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_openicon", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_openicon__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_openicon__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_openicon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::openicon() const\n"
    "    Fl_Tree::openicon(Fl_Image *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_closeicon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_closeicon" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Image *)((Fl_Tree const *)arg1)->closeicon(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Image, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_closeicon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Image *arg2 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_closeicon" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Image, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_closeicon" "', argument " "2"" of type '" "Fl_Image *""'"); 
  }
  arg2 = (Fl_Image *)(argp2);
  {
    try {
      (arg1)->closeicon(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_closeicon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_closeicon", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_closeicon__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_closeicon__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_closeicon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::closeicon() const\n"
    "    Fl_Tree::closeicon(Fl_Image *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_showcollapse__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_showcollapse" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->showcollapse(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_showcollapse__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_showcollapse" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_showcollapse" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->showcollapse(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_showcollapse(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_showcollapse", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_showcollapse__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_showcollapse__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_showcollapse'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::showcollapse() const\n"
    "    Fl_Tree::showcollapse(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_showroot__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_showroot" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->showroot(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_showroot__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_showroot" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_showroot" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->showroot(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_showroot(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_showroot", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_showroot__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_showroot__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_showroot'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::showroot() const\n"
    "    Fl_Tree::showroot(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_connectorstyle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Tree_Connector result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_connectorstyle" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Tree_Connector)((Fl_Tree const *)arg1)->connectorstyle(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_connectorstyle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Connector 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_connectorstyle" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_connectorstyle" "', argument " "2"" of type '" "Fl_Tree_Connector""'");
  } 
  arg2 = (Fl_Tree_Connector)(val2);
  {
    try {
      (arg1)->connectorstyle(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_connectorstyle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_connectorstyle", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_connectorstyle__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_connectorstyle__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_connectorstyle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::connectorstyle() const\n"
    "    Fl_Tree::connectorstyle(Fl_Tree_Connector)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_sortorder__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Tree_Sort result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_sortorder" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Tree_Sort)((Fl_Tree const *)arg1)->sortorder(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_sortorder__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Sort 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_sortorder" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_sortorder" "', argument " "2"" of type '" "Fl_Tree_Sort""'");
  } 
  arg2 = (Fl_Tree_Sort)(val2);
  {
    try {
      (arg1)->sortorder(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_sortorder(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_sortorder", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_sortorder__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_sortorder__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_sortorder'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::sortorder() const\n"
    "    Fl_Tree::sortorder(Fl_Tree_Sort)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_selectbox__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Boxtype result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_selectbox" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Boxtype)((Fl_Tree const *)arg1)->selectbox(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_selectbox__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Boxtype 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_selectbox" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_selectbox" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = (Fl_Boxtype)(val2);
  {
    try {
      (arg1)->selectbox(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_selectbox(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_selectbox", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_selectbox__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_selectbox__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_selectbox'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::selectbox() const\n"
    "    Fl_Tree::selectbox(Fl_Boxtype)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_selectmode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Tree_Select result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_selectmode" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Tree_Select)((Fl_Tree const *)arg1)->selectmode(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_selectmode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Select 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_selectmode" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_selectmode" "', argument " "2"" of type '" "Fl_Tree_Select""'");
  } 
  arg2 = (Fl_Tree_Select)(val2);
  {
    try {
      (arg1)->selectmode(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_selectmode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_selectmode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_selectmode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_selectmode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_selectmode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::selectmode() const\n"
    "    Fl_Tree::selectmode(Fl_Tree_Select)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_reselect_mode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Tree_Item_Reselect_Mode result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_item_reselect_mode" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Tree_Item_Reselect_Mode)((Fl_Tree const *)arg1)->item_reselect_mode(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_reselect_mode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item_Reselect_Mode 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_item_reselect_mode" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_item_reselect_mode" "', argument " "2"" of type '" "Fl_Tree_Item_Reselect_Mode""'");
  } 
  arg2 = (Fl_Tree_Item_Reselect_Mode)(val2);
  {
    try {
      (arg1)->item_reselect_mode(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_reselect_mode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_item_reselect_mode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_item_reselect_mode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_item_reselect_mode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_item_reselect_mode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::item_reselect_mode() const\n"
    "    Fl_Tree::item_reselect_mode(Fl_Tree_Item_Reselect_Mode)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_draw_mode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Tree_Item_Draw_Mode result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_item_draw_mode" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Tree_Item_Draw_Mode)((Fl_Tree const *)arg1)->item_draw_mode(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_draw_mode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item_Draw_Mode 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_item_draw_mode" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_item_draw_mode" "', argument " "2"" of type '" "Fl_Tree_Item_Draw_Mode""'");
  } 
  arg2 = (Fl_Tree_Item_Draw_Mode)(val2);
  {
    try {
      (arg1)->item_draw_mode(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_draw_mode__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_item_draw_mode" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_item_draw_mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->item_draw_mode(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_draw_mode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_item_draw_mode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_item_draw_mode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_item_draw_mode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_item_draw_mode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_item_draw_mode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::item_draw_mode() const\n"
    "    Fl_Tree::item_draw_mode(Fl_Tree_Item_Draw_Mode)\n"
    "    Fl_Tree::item_draw_mode(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_calc_dimensions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_calc_dimensions" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      (arg1)->calc_dimensions(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_calc_tree(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_calc_tree" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      (arg1)->calc_tree(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_recalc_tree(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_recalc_tree" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      (arg1)->recalc_tree(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_displayed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 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, "Fl_Tree_displayed", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_displayed" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_displayed" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      result = (int)(arg1)->displayed(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_show_item__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_show_item" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_show_item" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_show_item" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->show_item(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_show_item__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_show_item" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_show_item" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      (arg1)->show_item(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_show_item(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_show_item", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_show_item__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Tree_show_item__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_show_item'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::show_item(Fl_Tree_Item *,int)\n"
    "    Fl_Tree::show_item(Fl_Tree_Item *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_show_item_top(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_show_item_top", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_show_item_top" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_show_item_top" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      (arg1)->show_item_top(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_show_item_middle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_show_item_middle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_show_item_middle" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_show_item_middle" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      (arg1)->show_item_middle(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_show_item_bottom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_show_item_bottom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_show_item_bottom" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_show_item_bottom" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      (arg1)->show_item_bottom(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_display(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_display", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_display" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_display" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      (arg1)->display(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_vposition__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_vposition" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->vposition(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_vposition__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_vposition" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_vposition" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->vposition(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_vposition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_vposition", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_vposition__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_vposition__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_vposition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::vposition() const\n"
    "    Fl_Tree::vposition(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_hposition__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_hposition" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->hposition(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_hposition__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_hposition" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_hposition" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->hposition(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_hposition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_hposition", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_hposition__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_hposition__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_hposition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::hposition() const\n"
    "    Fl_Tree::hposition(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_is_scrollbar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 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, "Fl_Tree_is_scrollbar", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_is_scrollbar" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_is_scrollbar" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  {
    try {
      result = (int)(arg1)->is_scrollbar(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_scrollbar_size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_scrollbar_size" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->scrollbar_size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_scrollbar_size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_scrollbar_size" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_scrollbar_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      (arg1)->scrollbar_size(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_scrollbar_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_scrollbar_size", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_scrollbar_size__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_scrollbar_size__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_scrollbar_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::scrollbar_size() const\n"
    "    Fl_Tree::scrollbar_size(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_is_vscroll_visible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_is_vscroll_visible" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->is_vscroll_visible(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_is_hscroll_visible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_is_hscroll_visible" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (int)((Fl_Tree const *)arg1)->is_hscroll_visible(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_callback_item__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Item *arg2 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_callback_item" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_callback_item" "', argument " "2"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg2 = (Fl_Tree_Item *)(argp2);
  {
    try {
      (arg1)->callback_item(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_callback_item__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  Fl_Tree_Item *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_callback_item" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Tree_Item *)(arg1)->callback_item(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_callback_item(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_callback_item", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_callback_item__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_callback_item__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_callback_item'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::callback_item(Fl_Tree_Item *)\n"
    "    Fl_Tree::callback_item()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_callback_reason__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Reason 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_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_callback_reason" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_callback_reason" "', argument " "2"" of type '" "Fl_Tree_Reason""'");
  } 
  arg2 = (Fl_Tree_Reason)(val2);
  {
    try {
      (arg1)->callback_reason(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_callback_reason__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Tree_Reason result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_callback_reason" "', argument " "1"" of type '" "Fl_Tree const *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    try {
      result = (Fl_Tree_Reason)((Fl_Tree const *)arg1)->callback_reason(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_callback_reason(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Tree_callback_reason", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Tree_callback_reason__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Fl_Tree_callback_reason__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Tree_callback_reason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::callback_reason(Fl_Tree_Reason)\n"
    "    Fl_Tree::callback_reason() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_load(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Preferences *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Tree_load", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_load" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Fl_Preferences,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_load" "', argument " "2"" of type '" "Fl_Preferences &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "Fl_Tree_load" "', argument " "2"" of type '" "Fl_Preferences &""'"); 
  }
  arg2 = (Fl_Preferences *)(argp2);
  {
    try {
      (arg1)->load(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 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, "Fl_Tree_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tree_init_type" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      Fl_Tree_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Tree(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Tree" "', argument " "1"" of type '" "Fl_Tree *""'"); 
  }
  arg1 = (Fl_Tree *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Paged_Device(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  Fl_Paged_Device *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Paged_Device *)new SwigDirector_Fl_Paged_Device(arg1); 
      } else {
        SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
        SWIG_fail;
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Paged_Device, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Paged_Device(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Paged_Device, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Paged_Device" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = (Fl_Paged_Device *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_begin_job(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  int arg2 = (int) 0 ;
  int *arg3 = (int *) NULL ;
  int *arg4 = (int *) NULL ;
  char **arg5 = (char **) NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Paged_Device_begin_job", 1, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Paged_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Paged_Device_begin_job" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = (Fl_Paged_Device *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Paged_Device_begin_job" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  if (swig_obj[2]) {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Paged_Device_begin_job" "', argument " "3"" of type '" "int *""'"); 
    }
    arg3 = (int *)(argp3);
  }
  if (swig_obj[3]) {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Paged_Device_begin_job" "', argument " "4"" of type '" "int *""'"); 
    }
    arg4 = (int *)(argp4);
  }
  if (swig_obj[4]) {
    {
      /* Check if it is a list */
      if (PyList_Check(swig_obj[4])) {
        Py_ssize_t size = PyList_Size(swig_obj[4]);
        int i = 0;
        arg5 = (char **) malloc((size+1)*sizeof(char *));
        for (i = 0; i < size; i++) {
          PyObject *o = PyList_GetItem(swig_obj[4],i);
          
#if PY_VERSION_HEX>=0x03000000
          if (PyUnicode_Check(o))
#else  
          if (PyString_Check(o))
#endif
          {
            //arg5[i] = PyString_AsString(PyList_GetItem(swig_obj[4],i));
            //arg5[i] = SWIG_Python_str_AsChar(PyList_GetItem(swig_obj[4],i));
            arg5[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(swig_obj[4],i)));
          }
          else {
            PyErr_SetString(PyExc_TypeError,"list must contain strings");
            free(arg5);
            return NULL;
          }
          
        }
        arg5[i] = NULL;
        
      } else {
        PyErr_SetString(PyExc_TypeError,"not a list");
        return NULL;
      }
    }
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Paged_Device::begin_job(arg2,arg3,arg4,arg5);
        } else {
          result = (int)(arg1)->begin_job(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg5);
  }
  return resultobj;
fail:
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_start_job(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  int arg2 = (int) 0 ;
  int *arg3 = (int *) NULL ;
  int *arg4 = (int *) NULL ;
  char **arg5 = (char **) NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[5] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Paged_Device_start_job", 1, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Paged_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Paged_Device_start_job" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = (Fl_Paged_Device *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Paged_Device_start_job" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  if (swig_obj[2]) {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Paged_Device_start_job" "', argument " "3"" of type '" "int *""'"); 
    }
    arg3 = (int *)(argp3);
  }
  if (swig_obj[3]) {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Paged_Device_start_job" "', argument " "4"" of type '" "int *""'"); 
    }
    arg4 = (int *)(argp4);
  }
  if (swig_obj[4]) {
    {
      /* Check if it is a list */
      if (PyList_Check(swig_obj[4])) {
        Py_ssize_t size = PyList_Size(swig_obj[4]);
        int i = 0;
        arg5 = (char **) malloc((size+1)*sizeof(char *));
        for (i = 0; i < size; i++) {
          PyObject *o = PyList_GetItem(swig_obj[4],i);
          
#if PY_VERSION_HEX>=0x03000000
          if (PyUnicode_Check(o))
#else  
          if (PyString_Check(o))
#endif
          {
            //arg5[i] = PyString_AsString(PyList_GetItem(swig_obj[4],i));
            //arg5[i] = SWIG_Python_str_AsChar(PyList_GetItem(swig_obj[4],i));
            arg5[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(swig_obj[4],i)));
          }
          else {
            PyErr_SetString(PyExc_TypeError,"list must contain strings");
            free(arg5);
            return NULL;
          }
          
        }
        arg5[i] = NULL;
        
      } else {
        PyErr_SetString(PyExc_TypeError,"not a list");
        return NULL;
      }
    }
  }
  {
    try {
      result = (int)(arg1)->start_job(arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg5);
  }
  return resultobj;
fail:
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_begin_page(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Paged_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Paged_Device_begin_page" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = (Fl_Paged_Device *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Paged_Device::begin_page();
        } else {
          result = (int)(arg1)->begin_page();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_start_page(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 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_Fl_Paged_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Paged_Device_start_page" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = (Fl_Paged_Device *)(argp1);
  {
    try {
      result = (int)(arg1)->start_page(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_margins(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  int *arg4 = (int *) 0 ;
  int *arg5 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Paged_Device_margins", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Paged_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Paged_Device_margins" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = (Fl_Paged_Device *)(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 '" "Fl_Paged_Device_margins" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (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 '" "Fl_Paged_Device_margins" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Paged_Device_margins" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Fl_Paged_Device_margins" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Paged_Device::margins(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->margins(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_scale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  float arg2 ;
  float arg3 = (float) 0. ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Paged_Device_scale", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Paged_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Paged_Device_scale" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = (Fl_Paged_Device *)(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Paged_Device_scale" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = (float)(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Paged_Device_scale" "', argument " "3"" of type '" "float""'");
    } 
    arg3 = (float)(val3);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Paged_Device::scale(arg2,arg3);
        } else {
          (arg1)->scale(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_rotate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Paged_Device_rotate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Paged_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Paged_Device_rotate" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = (Fl_Paged_Device *)(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Paged_Device_rotate" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = (float)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Paged_Device::rotate(arg2);
        } else {
          (arg1)->rotate(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_print_widget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  int arg3 = (int) 0 ;
  int arg4 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Paged_Device_print_widget", 2, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Paged_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Paged_Device_print_widget" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = (Fl_Paged_Device *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Paged_Device_print_widget" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = (Fl_Widget *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Paged_Device_print_widget" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Paged_Device_print_widget" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  {
    try {
      (arg1)->print_widget(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_print_window(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  Fl_Window *arg2 = (Fl_Window *) 0 ;
  int arg3 = (int) 0 ;
  int arg4 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Paged_Device_print_window", 2, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Paged_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Paged_Device_print_window" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = (Fl_Paged_Device *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Paged_Device_print_window" "', argument " "2"" of type '" "Fl_Window *""'"); 
  }
  arg2 = (Fl_Window *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Paged_Device_print_window" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Paged_Device_print_window" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = (int)(val4);
  }
  {
    try {
      (arg1)->print_window(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_end_page(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Paged_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Paged_Device_end_page" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = (Fl_Paged_Device *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Paged_Device::end_page();
        } else {
          result = (int)(arg1)->end_page();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_end_job(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Paged_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Paged_Device_end_job" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = (Fl_Paged_Device *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Paged_Device::end_job();
        } else {
          (arg1)->end_job();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Paged_Device(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Paged_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Paged_Device" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = (Fl_Paged_Device *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_end_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Paged_Device *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Paged_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Paged_Device_end_current" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = (Fl_Paged_Device *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("end_current"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member end_current");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Paged_Device *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->end_currentSwigPublic();
        } else {
          (darg)->end_current();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_PDF_File_Surface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  Fl_PDF_File_Surface *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_PDF_File_Surface *)new SwigDirector_Fl_PDF_File_Surface(arg1); 
      } else {
        result = (Fl_PDF_File_Surface *)new Fl_PDF_File_Surface(); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_PDF_File_Surface, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_PDF_File_Surface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PDF_File_Surface, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_PDF_File_Surface" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_begin_job__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 0 ;
  char *arg2 = (char *) 0 ;
  char **arg3 = (char **) NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PDF_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PDF_File_Surface_begin_job" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_PDF_File_Surface_begin_job" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    {
      /* Check if it is a list */
      if (PyList_Check(swig_obj[2])) {
        Py_ssize_t size = PyList_Size(swig_obj[2]);
        int i = 0;
        arg3 = (char **) malloc((size+1)*sizeof(char *));
        for (i = 0; i < size; i++) {
          PyObject *o = PyList_GetItem(swig_obj[2],i);
          
#if PY_VERSION_HEX>=0x03000000
          if (PyUnicode_Check(o))
#else  
          if (PyString_Check(o))
#endif
          {
            //arg3[i] = PyString_AsString(PyList_GetItem(swig_obj[2],i));
            //arg3[i] = SWIG_Python_str_AsChar(PyList_GetItem(swig_obj[2],i));
            arg3[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(swig_obj[2],i)));
          }
          else {
            PyErr_SetString(PyExc_TypeError,"list must contain strings");
            free(arg3);
            return NULL;
          }
          
        }
        arg3[i] = NULL;
        
      } else {
        PyErr_SetString(PyExc_TypeError,"not a list");
        return NULL;
      }
    }
  }
  {
    try {
      result = (int)(arg1)->begin_job((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg3);
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_begin_job__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 0 ;
  int arg2 ;
  int *arg3 = (int *) 0 ;
  int *arg4 = (int *) 0 ;
  char **arg5 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PDF_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PDF_File_Surface_begin_job" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_PDF_File_Surface_begin_job" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (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 '" "Fl_PDF_File_Surface_begin_job" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_PDF_File_Surface_begin_job" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  {
    /* Check if it is a list */
    if (PyList_Check(swig_obj[4])) {
      Py_ssize_t size = PyList_Size(swig_obj[4]);
      int i = 0;
      arg5 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[4],i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg5[i] = PyString_AsString(PyList_GetItem(swig_obj[4],i));
          //arg5[i] = SWIG_Python_str_AsChar(PyList_GetItem(swig_obj[4],i));
          arg5[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(swig_obj[4],i)));
        }
        else {
          PyErr_SetString(PyExc_TypeError,"list must contain strings");
          free(arg5);
          return NULL;
        }
        
      }
      arg5[i] = NULL;
      
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_PDF_File_Surface::begin_job(arg2,arg3,arg4,arg5);
        } else {
          result = (int)(arg1)->begin_job(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg5);
  }
  return resultobj;
fail:
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_begin_job(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_PDF_File_Surface_begin_job", 0, 5, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    PyObject *retobj = _wrap_Fl_PDF_File_Surface_begin_job__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_Fl_PDF_File_Surface_begin_job__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_PDF_File_Surface_begin_job'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_PDF_File_Surface::begin_job(char const *,char **)\n"
    "    Fl_PDF_File_Surface::begin_job(int,int *,int *,char **)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_begin_document(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 0 ;
  char *arg2 = (char *) 0 ;
  enum Fl_Paged_Device::Page_Format arg3 = (enum Fl_Paged_Device::Page_Format) Fl_Paged_Device::A4 ;
  enum Fl_Paged_Device::Page_Layout arg4 = (enum Fl_Paged_Device::Page_Layout) Fl_Paged_Device::PORTRAIT ;
  char **arg5 = (char **) NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[5] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_PDF_File_Surface_begin_document", 2, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PDF_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PDF_File_Surface_begin_document" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_PDF_File_Surface_begin_document" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_PDF_File_Surface_begin_document" "', argument " "3"" of type '" "enum Fl_Paged_Device::Page_Format""'");
    } 
    arg3 = (enum Fl_Paged_Device::Page_Format)(val3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_PDF_File_Surface_begin_document" "', argument " "4"" of type '" "enum Fl_Paged_Device::Page_Layout""'");
    } 
    arg4 = (enum Fl_Paged_Device::Page_Layout)(val4);
  }
  if (swig_obj[4]) {
    {
      /* Check if it is a list */
      if (PyList_Check(swig_obj[4])) {
        Py_ssize_t size = PyList_Size(swig_obj[4]);
        int i = 0;
        arg5 = (char **) malloc((size+1)*sizeof(char *));
        for (i = 0; i < size; i++) {
          PyObject *o = PyList_GetItem(swig_obj[4],i);
          
#if PY_VERSION_HEX>=0x03000000
          if (PyUnicode_Check(o))
#else  
          if (PyString_Check(o))
#endif
          {
            //arg5[i] = PyString_AsString(PyList_GetItem(swig_obj[4],i));
            //arg5[i] = SWIG_Python_str_AsChar(PyList_GetItem(swig_obj[4],i));
            arg5[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(swig_obj[4],i)));
          }
          else {
            PyErr_SetString(PyExc_TypeError,"list must contain strings");
            free(arg5);
            return NULL;
          }
          
        }
        arg5[i] = NULL;
        
      } else {
        PyErr_SetString(PyExc_TypeError,"not a list");
        return NULL;
      }
    }
  }
  {
    try {
      result = (int)(arg1)->begin_document((char const *)arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg5);
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_printable_rect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  arg2 = &temp2;
  arg3 = &temp3;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PDF_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PDF_File_Surface_printable_rect" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_PDF_File_Surface::printable_rect(arg2,arg3);
        } else {
          result = (int)(arg1)->printable_rect(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_margins(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  int *arg4 = (int *) 0 ;
  int *arg5 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  int temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PDF_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PDF_File_Surface_margins" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_PDF_File_Surface::margins(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->margins(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_origin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PDF_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PDF_File_Surface_origin" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_PDF_File_Surface_origin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_PDF_File_Surface_origin" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_PDF_File_Surface::origin(arg2,arg3);
        } else {
          (arg1)->origin(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_origin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  arg2 = &temp2;
  arg3 = &temp3;
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PDF_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PDF_File_Surface_origin" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_PDF_File_Surface::origin(arg2,arg3);
        } else {
          (arg1)->origin(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_origin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_PDF_File_Surface_origin", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_PDF_File_Surface_origin__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_PDF_File_Surface_origin__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_PDF_File_Surface_origin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_PDF_File_Surface::origin(int,int)\n"
    "    Fl_PDF_File_Surface::origin(int *,int *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_scale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 0 ;
  float arg2 ;
  float arg3 = (float) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_PDF_File_Surface_scale", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PDF_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PDF_File_Surface_scale" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_PDF_File_Surface_scale" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = (float)(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_PDF_File_Surface_scale" "', argument " "3"" of type '" "float""'");
    } 
    arg3 = (float)(val3);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_PDF_File_Surface::scale(arg2,arg3);
        } else {
          (arg1)->scale(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_rotate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_PDF_File_Surface_rotate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PDF_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PDF_File_Surface_rotate" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_PDF_File_Surface_rotate" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = (float)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_PDF_File_Surface::rotate(arg2);
        } else {
          (arg1)->rotate(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_translate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 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] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_PDF_File_Surface_translate", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PDF_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PDF_File_Surface_translate" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_PDF_File_Surface_translate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_PDF_File_Surface_translate" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_PDF_File_Surface::translate(arg2,arg3);
        } else {
          (arg1)->translate(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_untranslate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PDF_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PDF_File_Surface_untranslate" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_PDF_File_Surface::untranslate();
        } else {
          (arg1)->untranslate();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_begin_page(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PDF_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PDF_File_Surface_begin_page" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_PDF_File_Surface::begin_page();
        } else {
          result = (int)(arg1)->begin_page();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_end_page(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PDF_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PDF_File_Surface_end_page" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_PDF_File_Surface::end_page();
        } else {
          result = (int)(arg1)->end_page();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_end_job(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PDF_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PDF_File_Surface_end_job" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_PDF_File_Surface::end_job();
        } else {
          (arg1)->end_job();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_pdf_filename(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 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_Fl_PDF_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PDF_File_Surface_pdf_filename" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  {
    try {
      result = (char *)(arg1)->pdf_filename(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_set_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PDF_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PDF_File_Surface_set_current" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  {
    try {
      (arg1)->set_current(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_is_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PDF_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PDF_File_Surface_is_current" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  {
    try {
      result = (bool)(arg1)->is_current(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_PDF_File_Surface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PDF_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_PDF_File_Surface" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PDF_File_Surface_end_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PDF_File_Surface *arg1 = (Fl_PDF_File_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_PDF_File_Surface *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PDF_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PDF_File_Surface_end_current" "', argument " "1"" of type '" "Fl_PDF_File_Surface *""'"); 
  }
  arg1 = (Fl_PDF_File_Surface *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("end_current"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member end_current");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_PDF_File_Surface *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->end_currentSwigPublic();
        } else {
          (darg)->end_current();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_PostScript_File_Device(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  Fl_PostScript_File_Device *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_PostScript_File_Device *)new SwigDirector_Fl_PostScript_File_Device(arg1); 
      } else {
        result = (Fl_PostScript_File_Device *)new Fl_PostScript_File_Device(); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_PostScript_File_Device, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_PostScript_File_Device(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_PostScript_File_Device" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_begin_job__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  int arg2 ;
  int *arg3 = (int *) 0 ;
  int *arg4 = (int *) 0 ;
  char **arg5 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_begin_job" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_PostScript_File_Device_begin_job" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (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 '" "Fl_PostScript_File_Device_begin_job" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_PostScript_File_Device_begin_job" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  {
    /* Check if it is a list */
    if (PyList_Check(swig_obj[4])) {
      Py_ssize_t size = PyList_Size(swig_obj[4]);
      int i = 0;
      arg5 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[4],i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg5[i] = PyString_AsString(PyList_GetItem(swig_obj[4],i));
          //arg5[i] = SWIG_Python_str_AsChar(PyList_GetItem(swig_obj[4],i));
          arg5[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(swig_obj[4],i)));
        }
        else {
          PyErr_SetString(PyExc_TypeError,"list must contain strings");
          free(arg5);
          return NULL;
        }
        
      }
      arg5[i] = NULL;
      
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_PostScript_File_Device::begin_job(arg2,arg3,arg4,arg5);
        } else {
          result = (int)(arg1)->begin_job(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg5);
  }
  return resultobj;
fail:
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_begin_job__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  int arg2 = (int) 0 ;
  enum Fl_Paged_Device::Page_Format arg3 = (enum Fl_Paged_Device::Page_Format) Fl_Paged_Device::A4 ;
  enum Fl_Paged_Device::Page_Layout arg4 = (enum Fl_Paged_Device::Page_Layout) Fl_Paged_Device::PORTRAIT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_begin_job" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_PostScript_File_Device_begin_job" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_PostScript_File_Device_begin_job" "', argument " "3"" of type '" "enum Fl_Paged_Device::Page_Format""'");
    } 
    arg3 = (enum Fl_Paged_Device::Page_Format)(val3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_PostScript_File_Device_begin_job" "', argument " "4"" of type '" "enum Fl_Paged_Device::Page_Layout""'");
    } 
    arg4 = (enum Fl_Paged_Device::Page_Layout)(val4);
  }
  {
    try {
      result = (int)(arg1)->begin_job(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_start_job__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  int arg2 = (int) 0 ;
  enum Fl_Paged_Device::Page_Format arg3 = (enum Fl_Paged_Device::Page_Format) Fl_Paged_Device::A4 ;
  enum Fl_Paged_Device::Page_Layout arg4 = (enum Fl_Paged_Device::Page_Layout) Fl_Paged_Device::PORTRAIT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_start_job" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_PostScript_File_Device_start_job" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_PostScript_File_Device_start_job" "', argument " "3"" of type '" "enum Fl_Paged_Device::Page_Format""'");
    } 
    arg3 = (enum Fl_Paged_Device::Page_Format)(val3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_PostScript_File_Device_start_job" "', argument " "4"" of type '" "enum Fl_Paged_Device::Page_Layout""'");
    } 
    arg4 = (enum Fl_Paged_Device::Page_Layout)(val4);
  }
  {
    try {
      result = (int)(arg1)->start_job(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_begin_job__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  FILE *arg2 = (FILE *) 0 ;
  int arg3 = (int) 0 ;
  enum Fl_Paged_Device::Page_Format arg4 = (enum Fl_Paged_Device::Page_Format) Fl_Paged_Device::A4 ;
  enum Fl_Paged_Device::Page_Layout arg5 = (enum Fl_Paged_Device::Page_Layout) Fl_Paged_Device::PORTRAIT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_begin_job" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_PostScript_File_Device_begin_job" "', argument " "2"" of type '" "FILE *""'"); 
  }
  arg2 = (FILE *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_PostScript_File_Device_begin_job" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_PostScript_File_Device_begin_job" "', argument " "4"" of type '" "enum Fl_Paged_Device::Page_Format""'");
    } 
    arg4 = (enum Fl_Paged_Device::Page_Format)(val4);
  }
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_PostScript_File_Device_begin_job" "', argument " "5"" of type '" "enum Fl_Paged_Device::Page_Layout""'");
    } 
    arg5 = (enum Fl_Paged_Device::Page_Layout)(val5);
  }
  {
    try {
      result = (int)(arg1)->begin_job(arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_begin_job(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_PostScript_File_Device_begin_job", 0, 5, argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 4)) {
    int _v = 0;
    if (argc > 1) {
      {
        {
          int res = SWIG_AsVal_int(argv[1], NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (!_v) goto check_1;
    }
    PyObject *retobj = _wrap_Fl_PostScript_File_Device_begin_job__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if ((argc >= 2) && (argc <= 5)) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FILE, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    if (argc > 2) {
      {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (!_v) goto check_2;
      if (argc > 3) {
        {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
        }
        if (!_v) goto check_2;
        if (argc > 4) {
          {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (!_v) goto check_2;
        }
      }
    }
    return _wrap_Fl_PostScript_File_Device_begin_job__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 5) {
    PyObject *retobj = _wrap_Fl_PostScript_File_Device_begin_job__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_PostScript_File_Device_begin_job'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_PostScript_File_Device::begin_job(int,int *,int *,char **)\n"
    "    Fl_PostScript_File_Device::begin_job(int,enum Fl_Paged_Device::Page_Format,enum Fl_Paged_Device::Page_Layout)\n"
    "    Fl_PostScript_File_Device::begin_job(FILE *,int,enum Fl_Paged_Device::Page_Format,enum Fl_Paged_Device::Page_Layout)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_start_job__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  FILE *arg2 = (FILE *) 0 ;
  int arg3 = (int) 0 ;
  enum Fl_Paged_Device::Page_Format arg4 = (enum Fl_Paged_Device::Page_Format) Fl_Paged_Device::A4 ;
  enum Fl_Paged_Device::Page_Layout arg5 = (enum Fl_Paged_Device::Page_Layout) Fl_Paged_Device::PORTRAIT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_start_job" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_PostScript_File_Device_start_job" "', argument " "2"" of type '" "FILE *""'"); 
  }
  arg2 = (FILE *)(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_PostScript_File_Device_start_job" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = (int)(val3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_PostScript_File_Device_start_job" "', argument " "4"" of type '" "enum Fl_Paged_Device::Page_Format""'");
    } 
    arg4 = (enum Fl_Paged_Device::Page_Format)(val4);
  }
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_PostScript_File_Device_start_job" "', argument " "5"" of type '" "enum Fl_Paged_Device::Page_Layout""'");
    } 
    arg5 = (enum Fl_Paged_Device::Page_Layout)(val5);
  }
  {
    try {
      result = (int)(arg1)->start_job(arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_start_job(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_PostScript_File_Device_start_job", 0, 5, argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 4)) {
    int _v = 0;
    if (argc > 1) {
      {
        {
          int res = SWIG_AsVal_int(argv[1], NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (!_v) goto check_1;
    }
    PyObject *retobj = _wrap_Fl_PostScript_File_Device_start_job__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if ((argc >= 2) && (argc <= 5)) {
    PyObject *retobj = _wrap_Fl_PostScript_File_Device_start_job__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_PostScript_File_Device_start_job'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_PostScript_File_Device::start_job(int,enum Fl_Paged_Device::Page_Format,enum Fl_Paged_Device::Page_Layout)\n"
    "    Fl_PostScript_File_Device::start_job(FILE *,int,enum Fl_Paged_Device::Page_Format,enum Fl_Paged_Device::Page_Layout)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_begin_page(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_begin_page" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_PostScript_File_Device::begin_page();
        } else {
          result = (int)(arg1)->begin_page();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_printable_rect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  arg2 = &temp2;
  arg3 = &temp3;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_printable_rect" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_PostScript_File_Device::printable_rect(arg2,arg3);
        } else {
          result = (int)(arg1)->printable_rect(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_margins(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  int *arg4 = (int *) 0 ;
  int *arg5 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  int temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_margins" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_PostScript_File_Device::margins(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->margins(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_origin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  arg2 = &temp2;
  arg3 = &temp3;
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_origin" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_PostScript_File_Device::origin(arg2,arg3);
        } else {
          (arg1)->origin(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_origin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_origin" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_PostScript_File_Device_origin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_PostScript_File_Device_origin" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_PostScript_File_Device::origin(arg2,arg3);
        } else {
          (arg1)->origin(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_origin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_PostScript_File_Device_origin", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_PostScript_File_Device_origin__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_PostScript_File_Device_origin__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_PostScript_File_Device_origin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_PostScript_File_Device::origin(int *,int *)\n"
    "    Fl_PostScript_File_Device::origin(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_scale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  float arg2 ;
  float arg3 = (float) 0. ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_PostScript_File_Device_scale", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_scale" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_PostScript_File_Device_scale" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = (float)(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_PostScript_File_Device_scale" "', argument " "3"" of type '" "float""'");
    } 
    arg3 = (float)(val3);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_PostScript_File_Device::scale(arg2,arg3);
        } else {
          (arg1)->scale(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_rotate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_PostScript_File_Device_rotate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_rotate" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_PostScript_File_Device_rotate" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = (float)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_PostScript_File_Device::rotate(arg2);
        } else {
          (arg1)->rotate(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_translate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 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] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_PostScript_File_Device_translate", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_translate" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_PostScript_File_Device_translate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_PostScript_File_Device_translate" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_PostScript_File_Device::translate(arg2,arg3);
        } else {
          (arg1)->translate(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_untranslate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_untranslate" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_PostScript_File_Device::untranslate();
        } else {
          (arg1)->untranslate();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_end_page(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_end_page" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_PostScript_File_Device::end_page();
        } else {
          result = (int)(arg1)->end_page();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_end_job(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_end_job" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_PostScript_File_Device::end_job();
        } else {
          (arg1)->end_job();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_file(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FILE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_file" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  {
    try {
      result = (FILE *)(arg1)->file(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FILE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_close_command(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  Fl_PostScript_Close_Command arg2 = (Fl_PostScript_Close_Command) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_PostScript_File_Device_close_command", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_close_command" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_FILE__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_PostScript_File_Device_close_command" "', argument " "2"" of type '" "Fl_PostScript_Close_Command""'"); 
    }
  }
  {
    try {
      (arg1)->close_command(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_set_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_set_current" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  {
    try {
      (arg1)->set_current(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_PostScript_File_Device_end_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_PostScript_File_Device_end_current" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  {
    try {
      (arg1)->end_current(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_PostScript_File_Device(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PostScript_File_Device *arg1 = (Fl_PostScript_File_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_PostScript_File_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_PostScript_File_Device" "', argument " "1"" of type '" "Fl_PostScript_File_Device *""'"); 
  }
  arg1 = (Fl_PostScript_File_Device *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_EPS_File_Surface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  FILE *arg3 = (FILE *) 0 ;
  Fl_Color arg4 = (Fl_Color) FL_WHITE ;
  Fl_PostScript_Close_Command arg5 = (Fl_PostScript_Close_Command) NULL ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[5] ;
  Fl_EPS_File_Surface *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Fl_EPS_File_Surface", 3, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Fl_EPS_File_Surface" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_EPS_File_Surface" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fl_EPS_File_Surface" "', argument " "3"" of type '" "FILE *""'"); 
  }
  arg3 = (FILE *)(argp3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_EPS_File_Surface" "', argument " "4"" of type '" "Fl_Color""'");
    } 
    arg4 = (Fl_Color)(val4);
  }
  if (swig_obj[4]) {
    {
      int res = SWIG_ConvertFunctionPtr(swig_obj[4], (void**)(&arg5), SWIGTYPE_p_f_p_FILE__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_Fl_EPS_File_Surface" "', argument " "5"" of type '" "Fl_PostScript_Close_Command""'"); 
      }
    }
  }
  {
    try {
      result = (Fl_EPS_File_Surface *)new Fl_EPS_File_Surface(arg1,arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_EPS_File_Surface, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_EPS_File_Surface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_EPS_File_Surface *arg1 = (Fl_EPS_File_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_EPS_File_Surface, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_EPS_File_Surface" "', argument " "1"" of type '" "Fl_EPS_File_Surface *""'"); 
  }
  arg1 = (Fl_EPS_File_Surface *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_EPS_File_Surface_printable_rect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_EPS_File_Surface *arg1 = (Fl_EPS_File_Surface *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  int result;
  
  arg2 = &temp2;
  arg3 = &temp3;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_EPS_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_EPS_File_Surface_printable_rect" "', argument " "1"" of type '" "Fl_EPS_File_Surface *""'"); 
  }
  arg1 = (Fl_EPS_File_Surface *)(argp1);
  {
    try {
      result = (int)(arg1)->printable_rect(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_EPS_File_Surface_file(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_EPS_File_Surface *arg1 = (Fl_EPS_File_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FILE *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_EPS_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_EPS_File_Surface_file" "', argument " "1"" of type '" "Fl_EPS_File_Surface *""'"); 
  }
  arg1 = (Fl_EPS_File_Surface *)(argp1);
  {
    try {
      result = (FILE *)(arg1)->file(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FILE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_EPS_File_Surface_origin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_EPS_File_Surface *arg1 = (Fl_EPS_File_Surface *) 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_Fl_EPS_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_EPS_File_Surface_origin" "', argument " "1"" of type '" "Fl_EPS_File_Surface *""'"); 
  }
  arg1 = (Fl_EPS_File_Surface *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_EPS_File_Surface_origin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_EPS_File_Surface_origin" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->origin(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_EPS_File_Surface_origin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_EPS_File_Surface *arg1 = (Fl_EPS_File_Surface *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 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_Fl_EPS_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_EPS_File_Surface_origin" "', argument " "1"" of type '" "Fl_EPS_File_Surface *""'"); 
  }
  arg1 = (Fl_EPS_File_Surface *)(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 '" "Fl_EPS_File_Surface_origin" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = (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 '" "Fl_EPS_File_Surface_origin" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  {
    try {
      (arg1)->origin(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_EPS_File_Surface_origin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_EPS_File_Surface_origin", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Fl_EPS_File_Surface_origin__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_EPS_File_Surface_origin__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_EPS_File_Surface_origin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_EPS_File_Surface::origin(int,int)\n"
    "    Fl_EPS_File_Surface::origin(int *,int *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_EPS_File_Surface_translate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_EPS_File_Surface *arg1 = (Fl_EPS_File_Surface *) 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, "Fl_EPS_File_Surface_translate", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_EPS_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_EPS_File_Surface_translate" "', argument " "1"" of type '" "Fl_EPS_File_Surface *""'"); 
  }
  arg1 = (Fl_EPS_File_Surface *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_EPS_File_Surface_translate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_EPS_File_Surface_translate" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      (arg1)->translate(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_EPS_File_Surface_untranslate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_EPS_File_Surface *arg1 = (Fl_EPS_File_Surface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_EPS_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_EPS_File_Surface_untranslate" "', argument " "1"" of type '" "Fl_EPS_File_Surface *""'"); 
  }
  arg1 = (Fl_EPS_File_Surface *)(argp1);
  {
    try {
      (arg1)->untranslate(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_EPS_File_Surface_close(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_EPS_File_Surface *arg1 = (Fl_EPS_File_Surface *) 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_Fl_EPS_File_Surface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_EPS_File_Surface_close" "', argument " "1"" of type '" "Fl_EPS_File_Surface *""'"); 
  }
  arg1 = (Fl_EPS_File_Surface *)(argp1);
  {
    try {
      result = (int)(arg1)->close(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Fl_Printer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  Fl_Printer *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (Fl_Printer *)new SwigDirector_Fl_Printer(arg1); 
      } else {
        result = (Fl_Printer *)new Fl_Printer(); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Printer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_begin_job(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  int arg2 = (int) 0 ;
  int *arg3 = (int *) NULL ;
  int *arg4 = (int *) NULL ;
  char **arg5 = (char **) NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Printer_begin_job", 1, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_begin_job" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = (Fl_Printer *)(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Printer_begin_job" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = (int)(val2);
  }
  if (swig_obj[2]) {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Printer_begin_job" "', argument " "3"" of type '" "int *""'"); 
    }
    arg3 = (int *)(argp3);
  }
  if (swig_obj[3]) {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Printer_begin_job" "', argument " "4"" of type '" "int *""'"); 
    }
    arg4 = (int *)(argp4);
  }
  if (swig_obj[4]) {
    {
      /* Check if it is a list */
      if (PyList_Check(swig_obj[4])) {
        Py_ssize_t size = PyList_Size(swig_obj[4]);
        int i = 0;
        arg5 = (char **) malloc((size+1)*sizeof(char *));
        for (i = 0; i < size; i++) {
          PyObject *o = PyList_GetItem(swig_obj[4],i);
          
#if PY_VERSION_HEX>=0x03000000
          if (PyUnicode_Check(o))
#else  
          if (PyString_Check(o))
#endif
          {
            //arg5[i] = PyString_AsString(PyList_GetItem(swig_obj[4],i));
            //arg5[i] = SWIG_Python_str_AsChar(PyList_GetItem(swig_obj[4],i));
            arg5[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(swig_obj[4],i)));
          }
          else {
            PyErr_SetString(PyExc_TypeError,"list must contain strings");
            free(arg5);
            return NULL;
          }
          
        }
        arg5[i] = NULL;
        
      } else {
        PyErr_SetString(PyExc_TypeError,"not a list");
        return NULL;
      }
    }
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Printer::begin_job(arg2,arg3,arg4,arg5);
        } else {
          result = (int)(arg1)->begin_job(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg5);
  }
  return resultobj;
fail:
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_begin_page(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_begin_page" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = (Fl_Printer *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Printer::begin_page();
        } else {
          result = (int)(arg1)->begin_page();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_printable_rect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  arg2 = &temp2;
  arg3 = &temp3;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_printable_rect" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = (Fl_Printer *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Printer::printable_rect(arg2,arg3);
        } else {
          result = (int)(arg1)->printable_rect(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_margins(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  int *arg4 = (int *) 0 ;
  int *arg5 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  int temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_margins" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = (Fl_Printer *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Printer::margins(arg2,arg3,arg4,arg5);
        } else {
          (arg1)->margins(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_origin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  arg2 = &temp2;
  arg3 = &temp3;
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_origin" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = (Fl_Printer *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Printer::origin(arg2,arg3);
        } else {
          (arg1)->origin(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_origin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_origin" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = (Fl_Printer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Printer_origin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Printer_origin" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Printer::origin(arg2,arg3);
        } else {
          (arg1)->origin(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_origin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fl_Printer_origin", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Fl_Printer_origin__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Fl_Printer_origin__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fl_Printer_origin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Printer::origin(int *,int *)\n"
    "    Fl_Printer::origin(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_scale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  float arg2 ;
  float arg3 = (float) 0. ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Printer_scale", 2, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_scale" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = (Fl_Printer *)(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Printer_scale" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = (float)(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Printer_scale" "', argument " "3"" of type '" "float""'");
    } 
    arg3 = (float)(val3);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Printer::scale(arg2,arg3);
        } else {
          (arg1)->scale(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_rotate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Printer_rotate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_rotate" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = (Fl_Printer *)(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Printer_rotate" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = (float)(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Printer::rotate(arg2);
        } else {
          (arg1)->rotate(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_translate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 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] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Fl_Printer_translate", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_translate" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = (Fl_Printer *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Printer_translate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Printer_translate" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Printer::translate(arg2,arg3);
        } else {
          (arg1)->translate(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_untranslate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_untranslate" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = (Fl_Printer *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Printer::untranslate();
        } else {
          (arg1)->untranslate();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_end_page(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_end_page" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = (Fl_Printer *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (int)(arg1)->Fl_Printer::end_page();
        } else {
          result = (int)(arg1)->end_page();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_end_job(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_end_job" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = (Fl_Printer *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Fl_Printer::end_job();
        } else {
          (arg1)->end_job();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_set_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_set_current" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = (Fl_Printer *)(argp1);
  {
    try {
      (arg1)->set_current(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_is_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_is_current" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = (Fl_Printer *)(argp1);
  {
    try {
      result = (bool)(arg1)->is_current(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool((bool)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Printer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Printer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Printer" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = (Fl_Printer *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Printer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Printer" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = (Fl_Printer *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_end_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Printer *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_end_current" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = (Fl_Printer *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("end_current"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member end_current");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Printer *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->end_currentSwigPublic();
        } else {
          (darg)->end_current();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_fl_utf8bytes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_utf8bytes" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = (unsigned int)(val1);
  {
    try {
      result = (int)fl_utf8bytes(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8len(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char arg1 ;
  char val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  int 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 '" "fl_utf8len" "', argument " "1"" of type '" "char""'");
  } 
  arg1 = (char)(val1);
  {
    try {
      result = (int)fl_utf8len(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf_nb_char(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 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, "fl_utf_nb_char", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf_nb_char" "', argument " "1"" of type '" "unsigned char const *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_utf_nb_char" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)fl_utf_nb_char((unsigned char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8decode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int *arg3 = (int *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  unsigned int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_utf8decode", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf8decode" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_utf8decode" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_utf8decode" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = (int *)(argp3);
  {
    try {
      result = (unsigned int)fl_utf8decode((char const *)arg1,(char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8encode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  char *arg2 = (char *) 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  char temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  int result;
  
  arg2 = &temp2;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_utf8encode" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = (unsigned int)(val1);
  {
    try {
      result = (int)fl_utf8encode(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_char((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_char, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8fwd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_utf8fwd", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf8fwd" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_utf8fwd" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_utf8fwd" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      result = (char *)fl_utf8fwd((char const *)arg1,(char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_utf8back", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf8back" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_utf8back" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_utf8back" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      result = (char *)fl_utf8back((char const *)arg1,(char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8toUtf16(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  unsigned int arg2 ;
  unsigned short *arg3 = (unsigned short *) 0 ;
  unsigned int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned short temp3 ;
  int res3 = SWIG_TMPOBJ ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[3] ;
  unsigned int result;
  
  arg3 = &temp3;
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_utf8toUtf16", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf8toUtf16" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_utf8toUtf16" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = (unsigned int)(val2);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_utf8toUtf16" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = (unsigned int)(val4);
  {
    try {
      result = (unsigned int)fl_utf8toUtf16((char const *)arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_short((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_short, new_flags), 0);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8toa(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  unsigned int arg2 ;
  char *arg3 = (char *) 0 ;
  unsigned int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  char temp3 ;
  int res3 = SWIG_TMPOBJ ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[3] ;
  unsigned int result;
  
  arg3 = &temp3;
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_utf8toa", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf8toa" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_utf8toa" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = (unsigned int)(val2);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_utf8toa" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = (unsigned int)(val4);
  {
    try {
      result = (unsigned int)fl_utf8toa((char const *)arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_char((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_char, new_flags), 0);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8froma(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  unsigned int arg2 ;
  char *arg3 = (char *) 0 ;
  unsigned int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  unsigned int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_utf8froma", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf8froma" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_utf8froma" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = (unsigned int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_utf8froma" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_utf8froma" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = (unsigned int)(val4);
  {
    try {
      result = (unsigned int)fl_utf8froma(arg1,arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8locale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_utf8locale", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)fl_utf8locale(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8test(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  unsigned int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_utf8test", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf8test" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_utf8test" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = (unsigned int)(val2);
  {
    try {
      result = (int)fl_utf8test((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_nonspacing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_nonspacing" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = (unsigned int)(val1);
  {
    try {
      result = (unsigned int)fl_nonspacing(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8to_mb(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  unsigned int arg2 ;
  char *arg3 = (char *) 0 ;
  unsigned int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  unsigned int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_utf8to_mb", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf8to_mb" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_utf8to_mb" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = (unsigned int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_utf8to_mb" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = (char *)(buf3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_utf8to_mb" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = (unsigned int)(val4);
  {
    try {
      result = (unsigned int)fl_utf8to_mb((char const *)arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf2mbcs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  char *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 '" "fl_utf2mbcs" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (char *)fl_utf2mbcs((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8from_mb(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  unsigned int arg2 ;
  char *arg3 = (char *) 0 ;
  unsigned int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  unsigned int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_utf8from_mb", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf8from_mb" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_utf8from_mb" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = (unsigned int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_utf8from_mb" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = (char *)(buf3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_utf8from_mb" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = (unsigned int)(val4);
  {
    try {
      result = (unsigned int)fl_utf8from_mb(arg1,arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8_to_locale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  unsigned int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_utf8_to_locale", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf8_to_locale" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_utf8_to_locale" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_utf8_to_locale" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = (unsigned int)(val3);
  {
    try {
      result = (char *)fl_utf8_to_locale((char const *)arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_locale_to_utf8(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  unsigned int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_locale_to_utf8", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_locale_to_utf8" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_locale_to_utf8" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_locale_to_utf8" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = (unsigned int)(val3);
  {
    try {
      result = (char *)fl_locale_to_utf8((char const *)arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf_strncasecmp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_utf_strncasecmp", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf_strncasecmp" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_utf_strncasecmp" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_utf_strncasecmp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  {
    try {
      result = (int)fl_utf_strncasecmp((char const *)arg1,(char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf_strcasecmp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_utf_strcasecmp", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf_strcasecmp" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_utf_strcasecmp" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)fl_utf_strcasecmp((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_tolower(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_tolower" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = (unsigned int)(val1);
  {
    try {
      result = (int)fl_tolower(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_toupper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_toupper" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = (unsigned int)(val1);
  {
    try {
      result = (int)fl_toupper(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf_tolower(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  arg3 = &temp3;
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_utf_tolower", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf_tolower" "', argument " "1"" of type '" "unsigned char const *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_utf_tolower" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)fl_utf_tolower((unsigned char const *)arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_char((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_char, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf_toupper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned char *arg1 = (unsigned char *) 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] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_utf_toupper", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf_toupper" "', argument " "1"" of type '" "unsigned char const *""'"); 
  }
  arg1 = (unsigned char *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_utf_toupper" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_utf_toupper" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = (char *)(buf3);
  {
    try {
      result = (int)fl_utf_toupper((unsigned char const *)arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_chmod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_chmod", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_chmod" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_chmod" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)fl_chmod((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_access(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_access", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_access" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_access" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)fl_access((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_getcwd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_getcwd", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_getcwd" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_getcwd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (char *)fl_getcwd(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_fopen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  FILE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_fopen", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_fopen" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_fopen" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (FILE *)fl_fopen((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FILE, 0 |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_system(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_system" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (int)fl_system((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_execvp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char **arg2 = (char **) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_execvp", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_execvp" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    /* Check if it is a list */
    if (PyList_Check(swig_obj[1])) {
      Py_ssize_t size = PyList_Size(swig_obj[1]);
      int i = 0;
      arg2 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[1],i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg2[i] = PyString_AsString(PyList_GetItem(swig_obj[1],i));
          //arg2[i] = SWIG_Python_str_AsChar(PyList_GetItem(swig_obj[1],i));
          arg2[i] = const_cast<char*>(PyUnicode_AsUTF8(PyList_GetItem(swig_obj[1],i)));
        }
        else {
          PyErr_SetString(PyExc_TypeError,"list must contain strings");
          free(arg2);
          return NULL;
        }
        
      }
      arg2[i] = NULL;
      
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  {
    try {
      result = (int)fl_execvp((char const *)arg1,(char *const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg2);
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    // this is a memory leak, but what the heck!
    // free((char*)arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_open__varargs__(PyObject *self, PyObject *args, PyObject *varargs) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  void *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  (void)self;
  if (!PyArg_UnpackTuple(args, "fl_open", 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 '" "fl_open" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_open" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)fl_open((char const *)arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_open(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_fl_open__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_fl_unlink(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_unlink" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (int)fl_unlink((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rmdir(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_rmdir" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (int)fl_rmdir((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_getenv(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  char *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 '" "fl_getenv" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (char *)fl_getenv((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_mkdir(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_mkdir", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_mkdir" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_mkdir" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  {
    try {
      result = (int)fl_mkdir((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rename(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "fl_rename", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_rename" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_rename" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      result = (int)fl_rename((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int((int)(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_make_path_for_file(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_make_path_for_file" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      fl_make_path_for_file((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_make_path(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_make_path" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = (char *)(buf1);
  {
    try {
      result = (char)fl_make_path((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new char(result)), SWIGTYPE_p_char, SWIG_POINTER_OWN |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_upCB(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "upCB", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "upCB" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(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 '" "upCB" "', argument " "2"" of type '" "void *""'"); 
  }
  {
    try {
      upCB(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_downCB(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "downCB", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "downCB" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(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 '" "downCB" "', argument " "2"" of type '" "void *""'"); 
  }
  {
    try {
      downCB(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_toggleCB(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "toggleCB", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "toggleCB" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = (Fl_Widget *)(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 '" "toggleCB" "', argument " "2"" of type '" "void *""'"); 
  }
  {
    try {
      toggleCB(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListSelect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  char *arg7 = (char *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  int res7 ;
  char *buf7 = 0 ;
  int alloc7 = 0 ;
  PyObject *swig_obj[7] ;
  ListSelect *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ListSelect", 5, 7, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListSelect" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ListSelect" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ListSelect" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ListSelect" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  if (swig_obj[5]) {
    res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ListSelect" "', argument " "6"" of type '" "char *""'");
    }
    arg6 = (char *)(buf6);
  }
  if (swig_obj[6]) {
    res7 = SWIG_AsCharPtrAndSize(swig_obj[6], &buf7, NULL, &alloc7);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ListSelect" "', argument " "7"" of type '" "char *""'");
    }
    arg7 = (char *)(buf7);
  }
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (ListSelect *)new SwigDirector_ListSelect(arg1,arg2,arg3,arg4,arg5,arg6,arg7); 
      } else {
        result = (ListSelect *)new ListSelect(arg2,arg3,arg4,arg5,arg6,arg7); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListSelect, SWIG_POINTER_NEW |  0 );
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
  return resultobj;
fail:
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListSelect_getTopBrowser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ListSelect *arg1 = (ListSelect *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Multi_Browser *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListSelect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListSelect_getTopBrowser" "', argument " "1"" of type '" "ListSelect *""'"); 
  }
  arg1 = (ListSelect *)(argp1);
  {
    try {
      result = (Fl_Multi_Browser *)(arg1)->getTopBrowser(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListSelect_getBottomBrowser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ListSelect *arg1 = (ListSelect *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Fl_Multi_Browser *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListSelect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListSelect_getBottomBrowser" "', argument " "1"" of type '" "ListSelect *""'"); 
  }
  arg1 = (ListSelect *)(argp1);
  {
    try {
      result = (Fl_Multi_Browser *)(arg1)->getBottomBrowser(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Multi_Browser, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListSelect_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ListSelect *arg1 = (ListSelect *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_ListSelect *darg = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ListSelect_resize", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListSelect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListSelect_resize" "', argument " "1"" of type '" "ListSelect *""'"); 
  }
  arg1 = (ListSelect *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListSelect_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListSelect_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ListSelect_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ListSelect_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = (int)(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("resize"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member resize");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_ListSelect *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->resizeSwigPublic(arg2,arg3,arg4,arg5);
        } else {
          (darg)->resize(arg2,arg3,arg4,arg5);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListSelect_init_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ListSelect *arg1 = (ListSelect *) 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, "ListSelect_init_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListSelect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListSelect_init_type" "', argument " "1"" of type '" "ListSelect *""'"); 
  }
  arg1 = (ListSelect *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListSelect_init_type" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = (char *)(buf2);
  {
    try {
      ListSelect_init_type(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ListSelect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ListSelect *arg1 = (ListSelect *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListSelect, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListSelect" "', argument " "1"" of type '" "ListSelect *""'"); 
  }
  arg1 = (ListSelect *)(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_ListSelect(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ListSelect *arg1 = (ListSelect *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListSelect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_ListSelect" "', argument " "1"" of type '" "ListSelect *""'"); 
  }
  arg1 = (ListSelect *)(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListSelect_draw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ListSelect *arg1 = (ListSelect *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_ListSelect *darg = 0;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListSelect, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListSelect_draw" "', argument " "1"" of type '" "ListSelect *""'"); 
  }
  arg1 = (ListSelect *)(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_ListSelect *>(arg1);
    {
      try {
        if (upcall) {
          (darg)->drawSwigPublic();
        } else {
          (darg)->draw();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_glLoadIdentity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "glLoadIdentity", 0, 0, 0)) SWIG_fail;
  {
    try {
      glLoadIdentity(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_glViewport(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "glViewport", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "glViewport" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "glViewport" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "glViewport" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = (int)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "glViewport" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = (int)(val4);
  {
    try {
      glViewport(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_glClear(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 '" "glClear" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      glClear(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_glColor3f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "glColor3f", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "glColor3f" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = (float)(val1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "glColor3f" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = (float)(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "glColor3f" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = (float)(val3);
  {
    try {
      glColor3f(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_glBegin(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 '" "glBegin" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = (int)(val1);
  {
    try {
      glBegin(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_glEnd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "glEnd", 0, 0, 0)) SWIG_fail;
  {
    try {
      glEnd(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_glVertex3f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "glVertex3f", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "glVertex3f" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = (float)(val1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "glVertex3f" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = (float)(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "glVertex3f" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = (float)(val3);
  {
    try {
      glVertex3f(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


static PyMethodDef SwigMethods[] = {
	 { "fl_define_FL_ROUND_UP_BOX", _wrap_fl_define_FL_ROUND_UP_BOX, METH_NOARGS, "fl_define_FL_ROUND_UP_BOX() -> Fl_Boxtype"},
	 { "fl_define_FL_SHADOW_BOX", _wrap_fl_define_FL_SHADOW_BOX, METH_NOARGS, "fl_define_FL_SHADOW_BOX() -> Fl_Boxtype"},
	 { "fl_define_FL_ROUNDED_BOX", _wrap_fl_define_FL_ROUNDED_BOX, METH_NOARGS, "fl_define_FL_ROUNDED_BOX() -> Fl_Boxtype"},
	 { "fl_define_FL_RFLAT_BOX", _wrap_fl_define_FL_RFLAT_BOX, METH_NOARGS, "fl_define_FL_RFLAT_BOX() -> Fl_Boxtype"},
	 { "fl_define_FL_RSHADOW_BOX", _wrap_fl_define_FL_RSHADOW_BOX, METH_NOARGS, "fl_define_FL_RSHADOW_BOX() -> Fl_Boxtype"},
	 { "fl_define_FL_DIAMOND_BOX", _wrap_fl_define_FL_DIAMOND_BOX, METH_NOARGS, "fl_define_FL_DIAMOND_BOX() -> Fl_Boxtype"},
	 { "fl_define_FL_OVAL_BOX", _wrap_fl_define_FL_OVAL_BOX, METH_NOARGS, "fl_define_FL_OVAL_BOX() -> Fl_Boxtype"},
	 { "fl_define_FL_PLASTIC_UP_BOX", _wrap_fl_define_FL_PLASTIC_UP_BOX, METH_NOARGS, "fl_define_FL_PLASTIC_UP_BOX() -> Fl_Boxtype"},
	 { "fl_define_FL_GTK_UP_BOX", _wrap_fl_define_FL_GTK_UP_BOX, METH_NOARGS, "fl_define_FL_GTK_UP_BOX() -> Fl_Boxtype"},
	 { "fl_define_FL_GLEAM_UP_BOX", _wrap_fl_define_FL_GLEAM_UP_BOX, METH_NOARGS, "fl_define_FL_GLEAM_UP_BOX() -> Fl_Boxtype"},
	 { "fl_define_FL_OXY_UP_BOX", _wrap_fl_define_FL_OXY_UP_BOX, METH_NOARGS, "fl_define_FL_OXY_UP_BOX() -> Fl_Boxtype"},
	 { "fl_box", _wrap_fl_box, METH_O, "fl_box(Fl_Boxtype b) -> Fl_Boxtype"},
	 { "fl_down", _wrap_fl_down, METH_O, "fl_down(Fl_Boxtype b) -> Fl_Boxtype"},
	 { "fl_define_FL_SHADOW_LABEL", _wrap_fl_define_FL_SHADOW_LABEL, METH_NOARGS, "fl_define_FL_SHADOW_LABEL() -> Fl_Labeltype"},
	 { "fl_define_FL_ENGRAVED_LABEL", _wrap_fl_define_FL_ENGRAVED_LABEL, METH_NOARGS, "fl_define_FL_ENGRAVED_LABEL() -> Fl_Labeltype"},
	 { "fl_define_FL_EMBOSSED_LABEL", _wrap_fl_define_FL_EMBOSSED_LABEL, METH_NOARGS, "fl_define_FL_EMBOSSED_LABEL() -> Fl_Labeltype"},
	 { "fl_define_FL_MULTI_LABEL", _wrap_fl_define_FL_MULTI_LABEL, METH_NOARGS, "fl_define_FL_MULTI_LABEL() -> Fl_Labeltype"},
	 { "fl_define_FL_ICON_LABEL", _wrap_fl_define_FL_ICON_LABEL, METH_NOARGS, "fl_define_FL_ICON_LABEL() -> Fl_Labeltype"},
	 { "fl_define_FL_IMAGE_LABEL", _wrap_fl_define_FL_IMAGE_LABEL, METH_NOARGS, "fl_define_FL_IMAGE_LABEL() -> Fl_Labeltype"},
	 { "fl_inactive", _wrap_fl_inactive, METH_O, "fl_inactive(Fl_Color c) -> Fl_Color"},
	 { "fl_contrast_function", _wrap_fl_contrast_function, METH_O, "fl_contrast_function(Fl_Contrast_Function * f)"},
	 { "fl_contrast_level", _wrap_fl_contrast_level, METH_VARARGS, "\n"
		"fl_contrast_level(int level)\n"
		"fl_contrast_level() -> int\n"
		""},
	 { "fl_contrast_mode", _wrap_fl_contrast_mode, METH_VARARGS, "\n"
		"fl_contrast_mode(int mode)\n"
		"fl_contrast_mode() -> int\n"
		""},
	 { "fl_contrast", _wrap_fl_contrast, METH_VARARGS, "fl_contrast(Fl_Color fg, Fl_Color bg, int context=0, int size=0) -> Fl_Color"},
	 { "fl_lightness", _wrap_fl_lightness, METH_O, "fl_lightness(Fl_Color color) -> double"},
	 { "fl_luminance", _wrap_fl_luminance, METH_O, "fl_luminance(Fl_Color color) -> double"},
	 { "fl_color_average", _wrap_fl_color_average, METH_VARARGS, "fl_color_average(Fl_Color c1, Fl_Color c2, float weight) -> Fl_Color"},
	 { "fl_lighter", _wrap_fl_lighter, METH_O, "fl_lighter(Fl_Color c) -> Fl_Color"},
	 { "fl_darker", _wrap_fl_darker, METH_O, "fl_darker(Fl_Color c) -> Fl_Color"},
	 { "fl_rgb_color", _wrap_fl_rgb_color, METH_VARARGS, "\n"
		"fl_rgb_color(uchar r, uchar g, uchar b) -> Fl_Color\n"
		"fl_rgb_color(uchar g) -> Fl_Color\n"
		""},
	 { "fl_gray_ramp", _wrap_fl_gray_ramp, METH_O, "fl_gray_ramp(int i) -> Fl_Color"},
	 { "fl_color_cube", _wrap_fl_color_cube, METH_VARARGS, "fl_color_cube(int r, int g, int b) -> Fl_Color"},
	 { "fl_command_modifier", _wrap_fl_command_modifier, METH_NOARGS, "fl_command_modifier() -> int"},
	 { "fl_control_modifier", _wrap_fl_control_modifier, METH_NOARGS, "fl_control_modifier() -> int"},
	 { "Fl_Image_w", _wrap_Fl_Image_w, METH_O, "Fl_Image_w(Fl_Image self) -> int"},
	 { "Fl_Image_h", _wrap_Fl_Image_h, METH_O, "Fl_Image_h(Fl_Image self) -> int"},
	 { "Fl_Image_data_w", _wrap_Fl_Image_data_w, METH_O, "Fl_Image_data_w(Fl_Image self) -> int"},
	 { "Fl_Image_data_h", _wrap_Fl_Image_data_h, METH_O, "Fl_Image_data_h(Fl_Image self) -> int"},
	 { "Fl_Image_d", _wrap_Fl_Image_d, METH_O, "Fl_Image_d(Fl_Image self) -> int"},
	 { "Fl_Image_ld", _wrap_Fl_Image_ld, METH_O, "Fl_Image_ld(Fl_Image self) -> int"},
	 { "Fl_Image_count", _wrap_Fl_Image_count, METH_O, "Fl_Image_count(Fl_Image self) -> int"},
	 { "Fl_Image_data", _wrap_Fl_Image_data, METH_O, "Fl_Image_data(Fl_Image self) -> char const *const *"},
	 { "Fl_Image_fail", _wrap_Fl_Image_fail, METH_O, "Fl_Image_fail(Fl_Image self) -> int"},
	 { "Fl_Image_release", _wrap_Fl_Image_release, METH_O, "Fl_Image_release(Fl_Image self)"},
	 { "Fl_Image_as_shared_image", _wrap_Fl_Image_as_shared_image, METH_O, "Fl_Image_as_shared_image(Fl_Image self) -> Fl_Shared_Image"},
	 { "new_Fl_Image", _wrap_new_Fl_Image, METH_VARARGS, "new_Fl_Image(PyObject * _self, int W, int H, int D) -> Fl_Image"},
	 { "delete_Fl_Image", _wrap_delete_Fl_Image, METH_O, "delete_Fl_Image(Fl_Image self)"},
	 { "Fl_Image_copy", _wrap_Fl_Image_copy, METH_VARARGS, "\n"
		"Fl_Image_copy(Fl_Image self, int W, int H) -> Fl_Image\n"
		"Fl_Image_copy(Fl_Image self) -> Fl_Image\n"
		""},
	 { "Fl_Image_color_average", _wrap_Fl_Image_color_average, METH_VARARGS, "Fl_Image_color_average(Fl_Image self, Fl_Color c, float i)"},
	 { "Fl_Image_inactive", _wrap_Fl_Image_inactive, METH_O, "Fl_Image_inactive(Fl_Image self)"},
	 { "Fl_Image_desaturate", _wrap_Fl_Image_desaturate, METH_O, "Fl_Image_desaturate(Fl_Image self)"},
	 { "Fl_Image_label", _wrap_Fl_Image_label, METH_VARARGS, "\n"
		"Fl_Image_label(Fl_Image self, Fl_Widget w)\n"
		"Fl_Image_label(Fl_Image self, Fl_Menu_Item m)\n"
		""},
	 { "Fl_Image_draw", _wrap_Fl_Image_draw, METH_VARARGS, "\n"
		"Fl_Image_draw(Fl_Image self, int X, int Y, int W, int H, int cx=0, int cy=0)\n"
		"Fl_Image_draw(Fl_Image self, int X, int Y)\n"
		""},
	 { "Fl_Image_uncache", _wrap_Fl_Image_uncache, METH_O, "Fl_Image_uncache(Fl_Image self)"},
	 { "Fl_Image_define_FL_IMAGE_LABEL", _wrap_Fl_Image_define_FL_IMAGE_LABEL, METH_NOARGS, "Fl_Image_define_FL_IMAGE_LABEL() -> Fl_Labeltype"},
	 { "Fl_Image_RGB_scaling", _wrap_Fl_Image_RGB_scaling, METH_VARARGS, "\n"
		"Fl_Image_RGB_scaling(Fl_RGB_Scaling arg1)\n"
		"Fl_Image_RGB_scaling() -> Fl_RGB_Scaling\n"
		""},
	 { "Fl_Image_scale", _wrap_Fl_Image_scale, METH_VARARGS, "Fl_Image_scale(Fl_Image self, int width, int height, int proportional=1, int can_expand=0)"},
	 { "Fl_Image_scaling_algorithm", _wrap_Fl_Image_scaling_algorithm, METH_VARARGS, "\n"
		"Fl_Image_scaling_algorithm(Fl_RGB_Scaling algorithm)\n"
		"Fl_Image_scaling_algorithm() -> Fl_RGB_Scaling\n"
		""},
	 { "disown_Fl_Image", _wrap_disown_Fl_Image, METH_O, NULL},
	 { "Fl_Image_swigregister", Fl_Image_swigregister, METH_O, NULL},
	 { "Fl_Image_swiginit", Fl_Image_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_RGB_Image", _wrap_new_Fl_RGB_Image, METH_VARARGS, "\n"
		"Fl_RGB_Image(uchar const * bits, int W, int H, int D=3, int LD=0)\n"
		"Fl_RGB_Image(uchar const * bits, int bits_length, int W, int H, int D, int LD)\n"
		"new_Fl_RGB_Image(PyObject * _self, Fl_Pixmap pxm, Fl_Color bg=) -> Fl_RGB_Image\n"
		""},
	 { "delete_Fl_RGB_Image", _wrap_delete_Fl_RGB_Image, METH_O, "delete_Fl_RGB_Image(Fl_RGB_Image self)"},
	 { "Fl_RGB_Image_copy", _wrap_Fl_RGB_Image_copy, METH_VARARGS, "\n"
		"Fl_RGB_Image_copy(Fl_RGB_Image self, int W, int H) -> Fl_Image\n"
		"Fl_RGB_Image_copy(Fl_RGB_Image self) -> Fl_Image\n"
		""},
	 { "Fl_RGB_Image_color_average", _wrap_Fl_RGB_Image_color_average, METH_VARARGS, "Fl_RGB_Image_color_average(Fl_RGB_Image self, Fl_Color c, float i)"},
	 { "Fl_RGB_Image_desaturate", _wrap_Fl_RGB_Image_desaturate, METH_O, "Fl_RGB_Image_desaturate(Fl_RGB_Image self)"},
	 { "Fl_RGB_Image_draw", _wrap_Fl_RGB_Image_draw, METH_VARARGS, "\n"
		"Fl_RGB_Image_draw(Fl_RGB_Image self, int X, int Y, int W, int H, int cx=0, int cy=0)\n"
		"Fl_RGB_Image_draw(Fl_RGB_Image self, int X, int Y)\n"
		""},
	 { "Fl_RGB_Image_label", _wrap_Fl_RGB_Image_label, METH_VARARGS, "\n"
		"Fl_RGB_Image_label(Fl_RGB_Image self, Fl_Widget w)\n"
		"Fl_RGB_Image_label(Fl_RGB_Image self, Fl_Menu_Item m)\n"
		""},
	 { "Fl_RGB_Image_uncache", _wrap_Fl_RGB_Image_uncache, METH_O, "Fl_RGB_Image_uncache(Fl_RGB_Image self)"},
	 { "Fl_RGB_Image_cache_w", _wrap_Fl_RGB_Image_cache_w, METH_O, "Fl_RGB_Image_cache_w(Fl_RGB_Image self) -> int"},
	 { "Fl_RGB_Image_cache_h", _wrap_Fl_RGB_Image_cache_h, METH_O, "Fl_RGB_Image_cache_h(Fl_RGB_Image self) -> int"},
	 { "Fl_RGB_Image_max_size", _wrap_Fl_RGB_Image_max_size, METH_VARARGS, "\n"
		"Fl_RGB_Image_max_size(size_t size)\n"
		"Fl_RGB_Image_max_size() -> size_t\n"
		""},
	 { "Fl_RGB_Image_as_svg_image", _wrap_Fl_RGB_Image_as_svg_image, METH_O, "Fl_RGB_Image_as_svg_image(Fl_RGB_Image self) -> Fl_SVG_Image"},
	 { "Fl_RGB_Image_normalize", _wrap_Fl_RGB_Image_normalize, METH_O, "Fl_RGB_Image_normalize(Fl_RGB_Image self)"},
	 { "disown_Fl_RGB_Image", _wrap_disown_Fl_RGB_Image, METH_O, NULL},
	 { "Fl_RGB_Image_swigregister", Fl_RGB_Image_swigregister, METH_O, NULL},
	 { "Fl_RGB_Image_swiginit", Fl_RGB_Image_swiginit, METH_VARARGS, NULL},
	 { "Fl_Label_draw", _wrap_Fl_Label_draw, METH_VARARGS, "Fl_Label_draw(Fl_Label self, int arg2, int arg3, int arg4, int arg5, Fl_Align arg6)"},
	 { "Fl_Label_measure", _wrap_Fl_Label_measure, METH_VARARGS, "Fl_Label_measure(Fl_Label self, int & w, int & h)"},
	 { "new_Fl_Label", _wrap_new_Fl_Label, METH_NOARGS, "new_Fl_Label() -> Fl_Label"},
	 { "delete_Fl_Label", _wrap_delete_Fl_Label, METH_O, "delete_Fl_Label(Fl_Label self)"},
	 { "Fl_Label_swigregister", Fl_Label_swigregister, METH_O, NULL},
	 { "Fl_Label_swiginit", Fl_Label_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Callback_User_Data", _wrap_new_Fl_Callback_User_Data, METH_O, "new_Fl_Callback_User_Data(PyObject * _self) -> Fl_Callback_User_Data"},
	 { "delete_Fl_Callback_User_Data", _wrap_delete_Fl_Callback_User_Data, METH_O, "delete_Fl_Callback_User_Data(Fl_Callback_User_Data self)"},
	 { "disown_Fl_Callback_User_Data", _wrap_disown_Fl_Callback_User_Data, METH_O, NULL},
	 { "Fl_Callback_User_Data_swigregister", Fl_Callback_User_Data_swigregister, METH_O, NULL},
	 { "Fl_Callback_User_Data_swiginit", Fl_Callback_User_Data_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Widget", _wrap_new_Fl_Widget, METH_VARARGS, "new_Fl_Widget(PyObject * _self, int x, int y, int w, int h, char const * label=None) -> Fl_Widget"},
	 { "delete_Fl_Widget", _wrap_delete_Fl_Widget, METH_O, "delete_Fl_Widget(Fl_Widget self)"},
	 { "Fl_Widget_draw", _wrap_Fl_Widget_draw, METH_O, "Fl_Widget_draw(Fl_Widget self)"},
	 { "Fl_Widget_handle", _wrap_Fl_Widget_handle, METH_VARARGS, "Fl_Widget_handle(Fl_Widget self, int event) -> int"},
	 { "Fl_Widget_is_label_copied", _wrap_Fl_Widget_is_label_copied, METH_O, "Fl_Widget_is_label_copied(Fl_Widget self) -> int"},
	 { "Fl_Widget_needs_keyboard", _wrap_Fl_Widget_needs_keyboard, METH_VARARGS, "\n"
		"Fl_Widget_needs_keyboard(Fl_Widget self, bool needs)\n"
		"Fl_Widget_needs_keyboard(Fl_Widget self) -> bool\n"
		""},
	 { "Fl_Widget_parent", _wrap_Fl_Widget_parent, METH_VARARGS, "\n"
		"Fl_Widget_parent(Fl_Widget self) -> Fl_Group\n"
		"Fl_Widget_parent(Fl_Widget self, Fl_Group p)\n"
		""},
	 { "Fl_Widget_type", _wrap_Fl_Widget_type, METH_VARARGS, "\n"
		"Fl_Widget_type(Fl_Widget self) -> uchar\n"
		"Fl_Widget_type(Fl_Widget self, uchar t)\n"
		""},
	 { "Fl_Widget_x", _wrap_Fl_Widget_x, METH_O, "Fl_Widget_x(Fl_Widget self) -> int"},
	 { "Fl_Widget_y", _wrap_Fl_Widget_y, METH_O, "Fl_Widget_y(Fl_Widget self) -> int"},
	 { "Fl_Widget_w", _wrap_Fl_Widget_w, METH_O, "Fl_Widget_w(Fl_Widget self) -> int"},
	 { "Fl_Widget_h", _wrap_Fl_Widget_h, METH_O, "Fl_Widget_h(Fl_Widget self) -> int"},
	 { "Fl_Widget_resize", _wrap_Fl_Widget_resize, METH_VARARGS, "Fl_Widget_resize(Fl_Widget self, int x, int y, int w, int h)"},
	 { "Fl_Widget_damage_resize", _wrap_Fl_Widget_damage_resize, METH_VARARGS, "Fl_Widget_damage_resize(Fl_Widget self, int arg2, int arg3, int arg4, int arg5) -> int"},
	 { "Fl_Widget_position", _wrap_Fl_Widget_position, METH_VARARGS, "Fl_Widget_position(Fl_Widget self, int X, int Y)"},
	 { "Fl_Widget_size", _wrap_Fl_Widget_size, METH_VARARGS, "Fl_Widget_size(Fl_Widget self, int W, int H)"},
	 { "Fl_Widget_align", _wrap_Fl_Widget_align, METH_VARARGS, "\n"
		"Fl_Widget_align(Fl_Widget self) -> Fl_Align\n"
		"Fl_Widget_align(Fl_Widget self, Fl_Align alignment)\n"
		""},
	 { "Fl_Widget_box", _wrap_Fl_Widget_box, METH_VARARGS, "\n"
		"Fl_Widget_box(Fl_Widget self) -> Fl_Boxtype\n"
		"Fl_Widget_box(Fl_Widget self, Fl_Boxtype new_box)\n"
		""},
	 { "Fl_Widget_selection_color", _wrap_Fl_Widget_selection_color, METH_VARARGS, "\n"
		"Fl_Widget_selection_color(Fl_Widget self) -> Fl_Color\n"
		"Fl_Widget_selection_color(Fl_Widget self, Fl_Color a)\n"
		""},
	 { "Fl_Widget_color", _wrap_Fl_Widget_color, METH_VARARGS, "\n"
		"Fl_Widget_color(Fl_Widget self) -> Fl_Color\n"
		"Fl_Widget_color(Fl_Widget self, Fl_Color bg)\n"
		"Fl_Widget_color(Fl_Widget self, Fl_Color bg, Fl_Color sel)\n"
		""},
	 { "Fl_Widget_copy_label", _wrap_Fl_Widget_copy_label, METH_VARARGS, "Fl_Widget_copy_label(Fl_Widget self, char const * new_label)"},
	 { "Fl_Widget_label", _wrap_Fl_Widget_label, METH_VARARGS, "\n"
		"Fl_Widget_label(Fl_Widget self) -> char const\n"
		"Fl_Widget_label(Fl_Widget self, char const * text)\n"
		"Fl_Widget_label(Fl_Widget self, Fl_Labeltype a, char const * b)\n"
		""},
	 { "Fl_Widget_labeltype", _wrap_Fl_Widget_labeltype, METH_VARARGS, "\n"
		"Fl_Widget_labeltype(Fl_Widget self) -> Fl_Labeltype\n"
		"Fl_Widget_labeltype(Fl_Widget self, Fl_Labeltype a)\n"
		""},
	 { "Fl_Widget_labelcolor", _wrap_Fl_Widget_labelcolor, METH_VARARGS, "\n"
		"Fl_Widget_labelcolor(Fl_Widget self) -> Fl_Color\n"
		"Fl_Widget_labelcolor(Fl_Widget self, Fl_Color c)\n"
		""},
	 { "Fl_Widget_labelfont", _wrap_Fl_Widget_labelfont, METH_VARARGS, "\n"
		"Fl_Widget_labelfont(Fl_Widget self) -> Fl_Font\n"
		"Fl_Widget_labelfont(Fl_Widget self, Fl_Font f)\n"
		""},
	 { "Fl_Widget_labelsize", _wrap_Fl_Widget_labelsize, METH_VARARGS, "\n"
		"Fl_Widget_labelsize(Fl_Widget self) -> Fl_Fontsize\n"
		"Fl_Widget_labelsize(Fl_Widget self, Fl_Fontsize pix)\n"
		""},
	 { "Fl_Widget_image", _wrap_Fl_Widget_image, METH_VARARGS, "\n"
		"Fl_Widget_image(Fl_Widget self) -> Fl_Image\n"
		"Fl_Widget_image(Fl_Widget self) -> Fl_Image\n"
		"Fl_Widget_image(Fl_Widget self, Fl_Image img)\n"
		""},
	 { "Fl_Widget_bind_image", _wrap_Fl_Widget_bind_image, METH_VARARGS, "\n"
		"Fl_Widget_bind_image(Fl_Widget self, Fl_Image img)\n"
		"Fl_Widget_bind_image(Fl_Widget self, int f)\n"
		""},
	 { "Fl_Widget_image_bound", _wrap_Fl_Widget_image_bound, METH_O, "Fl_Widget_image_bound(Fl_Widget self) -> int"},
	 { "Fl_Widget_deimage", _wrap_Fl_Widget_deimage, METH_VARARGS, "\n"
		"Fl_Widget_deimage(Fl_Widget self) -> Fl_Image\n"
		"Fl_Widget_deimage(Fl_Widget self) -> Fl_Image\n"
		"Fl_Widget_deimage(Fl_Widget self, Fl_Image img)\n"
		""},
	 { "Fl_Widget_deimage_bound", _wrap_Fl_Widget_deimage_bound, METH_O, "Fl_Widget_deimage_bound(Fl_Widget self) -> int"},
	 { "Fl_Widget_bind_deimage", _wrap_Fl_Widget_bind_deimage, METH_VARARGS, "\n"
		"Fl_Widget_bind_deimage(Fl_Widget self, Fl_Image img)\n"
		"Fl_Widget_bind_deimage(Fl_Widget self, int f)\n"
		""},
	 { "Fl_Widget_label_image_spacing", _wrap_Fl_Widget_label_image_spacing, METH_VARARGS, "\n"
		"Fl_Widget_label_image_spacing(Fl_Widget self, int gap)\n"
		"Fl_Widget_label_image_spacing(Fl_Widget self) -> int\n"
		""},
	 { "Fl_Widget_horizontal_label_margin", _wrap_Fl_Widget_horizontal_label_margin, METH_VARARGS, "\n"
		"Fl_Widget_horizontal_label_margin(Fl_Widget self, int px)\n"
		"Fl_Widget_horizontal_label_margin(Fl_Widget self) -> int\n"
		""},
	 { "Fl_Widget_vertical_label_margin", _wrap_Fl_Widget_vertical_label_margin, METH_VARARGS, "\n"
		"Fl_Widget_vertical_label_margin(Fl_Widget self, int px)\n"
		"Fl_Widget_vertical_label_margin(Fl_Widget self) -> int\n"
		""},
	 { "Fl_Widget_tooltip", _wrap_Fl_Widget_tooltip, METH_VARARGS, "\n"
		"Fl_Widget_tooltip(Fl_Widget self) -> char const\n"
		"Fl_Widget_tooltip(Fl_Widget self, char const * text)\n"
		""},
	 { "Fl_Widget_copy_tooltip", _wrap_Fl_Widget_copy_tooltip, METH_VARARGS, "Fl_Widget_copy_tooltip(Fl_Widget self, char const * text)"},
	 { "Fl_Widget_argument", _wrap_Fl_Widget_argument, METH_VARARGS, "\n"
		"Fl_Widget_argument(Fl_Widget self) -> long\n"
		"Fl_Widget_argument(Fl_Widget self, long v)\n"
		""},
	 { "Fl_Widget_when", _wrap_Fl_Widget_when, METH_VARARGS, "\n"
		"Fl_Widget_when(Fl_Widget self) -> Fl_When\n"
		"Fl_Widget_when(Fl_Widget self, uchar i)\n"
		""},
	 { "Fl_Widget_visible", _wrap_Fl_Widget_visible, METH_O, "Fl_Widget_visible(Fl_Widget self) -> unsigned int"},
	 { "Fl_Widget_visible_r", _wrap_Fl_Widget_visible_r, METH_O, "Fl_Widget_visible_r(Fl_Widget self) -> int"},
	 { "Fl_Widget_show", _wrap_Fl_Widget_show, METH_O, "Fl_Widget_show(Fl_Widget self)"},
	 { "Fl_Widget_hide", _wrap_Fl_Widget_hide, METH_O, "Fl_Widget_hide(Fl_Widget self)"},
	 { "Fl_Widget_set_visible", _wrap_Fl_Widget_set_visible, METH_O, "Fl_Widget_set_visible(Fl_Widget self)"},
	 { "Fl_Widget_clear_visible", _wrap_Fl_Widget_clear_visible, METH_O, "Fl_Widget_clear_visible(Fl_Widget self)"},
	 { "Fl_Widget_active", _wrap_Fl_Widget_active, METH_O, "Fl_Widget_active(Fl_Widget self) -> unsigned int"},
	 { "Fl_Widget_active_r", _wrap_Fl_Widget_active_r, METH_O, "Fl_Widget_active_r(Fl_Widget self) -> int"},
	 { "Fl_Widget_activate", _wrap_Fl_Widget_activate, METH_O, "Fl_Widget_activate(Fl_Widget self)"},
	 { "Fl_Widget_deactivate", _wrap_Fl_Widget_deactivate, METH_O, "Fl_Widget_deactivate(Fl_Widget self)"},
	 { "Fl_Widget_output", _wrap_Fl_Widget_output, METH_O, "Fl_Widget_output(Fl_Widget self) -> unsigned int"},
	 { "Fl_Widget_set_output", _wrap_Fl_Widget_set_output, METH_O, "Fl_Widget_set_output(Fl_Widget self)"},
	 { "Fl_Widget_clear_output", _wrap_Fl_Widget_clear_output, METH_O, "Fl_Widget_clear_output(Fl_Widget self)"},
	 { "Fl_Widget_takesevents", _wrap_Fl_Widget_takesevents, METH_O, "Fl_Widget_takesevents(Fl_Widget self) -> unsigned int"},
	 { "Fl_Widget_changed", _wrap_Fl_Widget_changed, METH_O, "Fl_Widget_changed(Fl_Widget self) -> unsigned int"},
	 { "Fl_Widget_set_changed", _wrap_Fl_Widget_set_changed, METH_O, "Fl_Widget_set_changed(Fl_Widget self)"},
	 { "Fl_Widget_clear_changed", _wrap_Fl_Widget_clear_changed, METH_O, "Fl_Widget_clear_changed(Fl_Widget self)"},
	 { "Fl_Widget_clear_active", _wrap_Fl_Widget_clear_active, METH_O, "Fl_Widget_clear_active(Fl_Widget self)"},
	 { "Fl_Widget_set_active", _wrap_Fl_Widget_set_active, METH_O, "Fl_Widget_set_active(Fl_Widget self)"},
	 { "Fl_Widget_take_focus", _wrap_Fl_Widget_take_focus, METH_O, "Fl_Widget_take_focus(Fl_Widget self) -> int"},
	 { "Fl_Widget_set_visible_focus", _wrap_Fl_Widget_set_visible_focus, METH_O, "Fl_Widget_set_visible_focus(Fl_Widget self)"},
	 { "Fl_Widget_clear_visible_focus", _wrap_Fl_Widget_clear_visible_focus, METH_O, "Fl_Widget_clear_visible_focus(Fl_Widget self)"},
	 { "Fl_Widget_visible_focus", _wrap_Fl_Widget_visible_focus, METH_VARARGS, "\n"
		"Fl_Widget_visible_focus(Fl_Widget self, int v)\n"
		"Fl_Widget_visible_focus(Fl_Widget self) -> unsigned int\n"
		""},
	 { "Fl_Widget_default_callback", _wrap_Fl_Widget_default_callback, METH_VARARGS, "Fl_Widget_default_callback(Fl_Widget widget, void * data)"},
	 { "Fl_Widget_do_callback", _wrap_Fl_Widget_do_callback, METH_VARARGS, "\n"
		"Fl_Widget_do_callback(Fl_Widget self, Fl_Callback_Reason reason=FL_REASON_UNKNOWN)\n"
		"Fl_Widget_do_callback(Fl_Widget self, Fl_Widget widget, long arg, Fl_Callback_Reason reason=FL_REASON_UNKNOWN)\n"
		"Fl_Widget_do_callback(Fl_Widget self, Fl_Widget widget, void * arg=None, Fl_Callback_Reason reason=FL_REASON_UNKNOWN)\n"
		""},
	 { "Fl_Widget_label_shortcut", _wrap_Fl_Widget_label_shortcut, METH_O, "Fl_Widget_label_shortcut(char const * t) -> unsigned int"},
	 { "Fl_Widget_test_shortcut", _wrap_Fl_Widget_test_shortcut, METH_VARARGS, "\n"
		"Fl_Widget_test_shortcut() -> int\n"
		"Fl_Widget_test_shortcut(char const * arg1, bool const require_alt=False) -> int\n"
		""},
	 { "Fl_Widget__set_fullscreen", _wrap_Fl_Widget__set_fullscreen, METH_O, "Fl_Widget__set_fullscreen(Fl_Widget self)"},
	 { "Fl_Widget__clear_fullscreen", _wrap_Fl_Widget__clear_fullscreen, METH_O, "Fl_Widget__clear_fullscreen(Fl_Widget self)"},
	 { "Fl_Widget_contains", _wrap_Fl_Widget_contains, METH_VARARGS, "Fl_Widget_contains(Fl_Widget self, Fl_Widget w) -> int"},
	 { "Fl_Widget_inside", _wrap_Fl_Widget_inside, METH_VARARGS, "Fl_Widget_inside(Fl_Widget self, Fl_Widget wgt) -> int"},
	 { "Fl_Widget_redraw", _wrap_Fl_Widget_redraw, METH_O, "Fl_Widget_redraw(Fl_Widget self)"},
	 { "Fl_Widget_redraw_label", _wrap_Fl_Widget_redraw_label, METH_O, "Fl_Widget_redraw_label(Fl_Widget self)"},
	 { "Fl_Widget_clear_damage", _wrap_Fl_Widget_clear_damage, METH_VARARGS, "Fl_Widget_clear_damage(Fl_Widget self, uchar c=0)"},
	 { "Fl_Widget_damage", _wrap_Fl_Widget_damage, METH_VARARGS, "\n"
		"Fl_Widget_damage(Fl_Widget self) -> uchar\n"
		"Fl_Widget_damage(Fl_Widget self, uchar c)\n"
		"Fl_Widget_damage(Fl_Widget self, uchar c, int x, int y, int w, int h)\n"
		""},
	 { "Fl_Widget_measure_label", _wrap_Fl_Widget_measure_label, METH_VARARGS, "Fl_Widget_measure_label(Fl_Widget self, int & ww, int & hh)"},
	 { "Fl_Widget_window", _wrap_Fl_Widget_window, METH_O, "Fl_Widget_window(Fl_Widget self) -> Fl_Window"},
	 { "Fl_Widget_top_window", _wrap_Fl_Widget_top_window, METH_O, "Fl_Widget_top_window(Fl_Widget self) -> Fl_Window"},
	 { "Fl_Widget_top_window_offset", _wrap_Fl_Widget_top_window_offset, METH_VARARGS, "Fl_Widget_top_window_offset(Fl_Widget self, int & xoff, int & yoff) -> Fl_Window"},
	 { "Fl_Widget_as_group", _wrap_Fl_Widget_as_group, METH_VARARGS, "\n"
		"Fl_Widget_as_group(Fl_Widget self) -> Fl_Group\n"
		"Fl_Widget_as_group(Fl_Widget self) -> Fl_Group\n"
		""},
	 { "Fl_Widget_as_window", _wrap_Fl_Widget_as_window, METH_VARARGS, "\n"
		"Fl_Widget_as_window(Fl_Widget self) -> Fl_Window\n"
		"Fl_Widget_as_window(Fl_Widget self) -> Fl_Window\n"
		""},
	 { "Fl_Widget_as_gl_window", _wrap_Fl_Widget_as_gl_window, METH_VARARGS, "\n"
		"Fl_Widget_as_gl_window(Fl_Widget self) -> Fl_Gl_Window\n"
		"Fl_Widget_as_gl_window(Fl_Widget self) -> Fl_Gl_Window\n"
		""},
	 { "Fl_Widget_as_vk_window", _wrap_Fl_Widget_as_vk_window, METH_VARARGS, "\n"
		"Fl_Widget_as_vk_window(Fl_Widget self) -> Fl_Vk_Window\n"
		"Fl_Widget_as_vk_window(Fl_Widget self) -> Fl_Vk_Window const *\n"
		""},
	 { "Fl_Widget_use_accents_menu", _wrap_Fl_Widget_use_accents_menu, METH_O, "Fl_Widget_use_accents_menu(Fl_Widget self) -> int"},
	 { "Fl_Widget_shortcut_label", _wrap_Fl_Widget_shortcut_label, METH_VARARGS, "\n"
		"Fl_Widget_shortcut_label(Fl_Widget self, int value)\n"
		"Fl_Widget_shortcut_label(Fl_Widget self) -> int\n"
		""},
	 { "Fl_Widget_init_type", _wrap_Fl_Widget_init_type, METH_VARARGS, "Fl_Widget_init_type(Fl_Widget self, char * Fl_Widget)"},
	 { "Fl_Widget_draw_label", _wrap_Fl_Widget_draw_label, METH_VARARGS, "\n"
		"Fl_Widget_draw_label(Fl_Widget self, int arg2, int arg3, int arg4, int arg5, Fl_Align arg6)\n"
		"Fl_Widget_draw_label(Fl_Widget self)\n"
		""},
	 { "Fl_Widget_draw_backdrop", _wrap_Fl_Widget_draw_backdrop, METH_O, "Fl_Widget_draw_backdrop(Fl_Widget self)"},
	 { "Fl_Widget_callback", _wrap_Fl_Widget_callback, METH_VARARGS, "\n"
		"Fl_Widget_callback(Fl_Widget self) -> Fl_Callback_p\n"
		"Fl_Widget_callback(Fl_Widget self, Fl_Callback * cb, void * p)\n"
		"Fl_Widget_callback(Fl_Widget self, Fl_Callback * cb, Fl_Callback_User_Data p, bool auto_free)\n"
		"Fl_Widget_callback(Fl_Widget self, Fl_Callback * cb)\n"
		"Fl_Widget_callback(Fl_Widget self, Fl_Callback0 * cb)\n"
		"Fl_Widget_callback(Fl_Widget self, Fl_Callback1 * cb, long p=0)\n"
		"Fl_Widget_callback(Fl_Widget self, PyObject * PyFunc, PyObject * PyWidget, PyObject * PyData=None)\n"
		""},
	 { "Fl_Widget_user_data", _wrap_Fl_Widget_user_data, METH_VARARGS, "\n"
		"Fl_Widget_user_data(Fl_Widget self, Fl_Callback_User_Data v, bool auto_free)\n"
		"Fl_Widget_user_data(Fl_Widget self, PyObject * PyData)\n"
		"Fl_Widget_user_data(Fl_Widget self) -> PyObject *\n"
		""},
	 { "disown_Fl_Widget", _wrap_disown_Fl_Widget, METH_O, NULL},
	 { "Fl_Widget_swigregister", Fl_Widget_swigregister, METH_O, NULL},
	 { "Fl_Widget_swiginit", Fl_Widget_swiginit, METH_VARARGS, NULL},
	 { "Fl_Widget_Surface_translate", _wrap_Fl_Widget_Surface_translate, METH_VARARGS, "Fl_Widget_Surface_translate(Fl_Widget_Surface self, int x, int y)"},
	 { "Fl_Widget_Surface_untranslate", _wrap_Fl_Widget_Surface_untranslate, METH_O, "Fl_Widget_Surface_untranslate(Fl_Widget_Surface self)"},
	 { "Fl_Widget_Surface_draw", _wrap_Fl_Widget_Surface_draw, METH_VARARGS, "Fl_Widget_Surface_draw(Fl_Widget_Surface self, Fl_Widget widget, int delta_x=0, int delta_y=0)"},
	 { "Fl_Widget_Surface_draw_decorated_window", _wrap_Fl_Widget_Surface_draw_decorated_window, METH_VARARGS, "Fl_Widget_Surface_draw_decorated_window(Fl_Widget_Surface self, Fl_Window win, int x_offset=0, int y_offset=0)"},
	 { "Fl_Widget_Surface_print_window_part", _wrap_Fl_Widget_Surface_print_window_part, METH_VARARGS, "Fl_Widget_Surface_print_window_part(Fl_Widget_Surface self, Fl_Window win, int x, int y, int w, int h, int delta_x=0, int delta_y=0)"},
	 { "Fl_Widget_Surface_printable_rect", _wrap_Fl_Widget_Surface_printable_rect, METH_VARARGS, "Fl_Widget_Surface_printable_rect(Fl_Widget_Surface self, int * w, int * h) -> int"},
	 { "Fl_Widget_Surface_origin", _wrap_Fl_Widget_Surface_origin, METH_VARARGS, "\n"
		"Fl_Widget_Surface_origin(Fl_Widget_Surface self, int x, int y)\n"
		"Fl_Widget_Surface_origin(Fl_Widget_Surface self, int * x, int * y)\n"
		""},
	 { "delete_Fl_Widget_Surface", _wrap_delete_Fl_Widget_Surface, METH_O, "delete_Fl_Widget_Surface(Fl_Widget_Surface self)"},
	 { "Fl_Widget_Surface_swigregister", Fl_Widget_Surface_swigregister, METH_O, NULL},
	 { "Fl_Group_draw", _wrap_Fl_Group_draw, METH_O, "Fl_Group_draw(Fl_Group self)"},
	 { "Fl_Group_handle", _wrap_Fl_Group_handle, METH_VARARGS, "Fl_Group_handle(Fl_Group self, int arg0) -> int"},
	 { "Fl_Group_begin", _wrap_Fl_Group_begin, METH_O, "Fl_Group_begin(Fl_Group self)"},
	 { "Fl_Group_end", _wrap_Fl_Group_end, METH_O, "Fl_Group_end(Fl_Group self)"},
	 { "Fl_Group_current", _wrap_Fl_Group_current, METH_VARARGS, "\n"
		"Fl_Group_current() -> Fl_Group\n"
		"Fl_Group_current(Fl_Group g)\n"
		""},
	 { "Fl_Group_children", _wrap_Fl_Group_children, METH_O, "Fl_Group_children(Fl_Group self) -> int"},
	 { "Fl_Group_child", _wrap_Fl_Group_child, METH_VARARGS, "Fl_Group_child(Fl_Group self, int n) -> Fl_Widget"},
	 { "Fl_Group_find", _wrap_Fl_Group_find, METH_VARARGS, "Fl_Group_find(Fl_Group self, Fl_Widget o) -> int"},
	 { "Fl_Group_resize", _wrap_Fl_Group_resize, METH_VARARGS, "Fl_Group_resize(Fl_Group self, int arg0, int arg1, int arg2, int arg3)"},
	 { "new_Fl_Group", _wrap_new_Fl_Group, METH_VARARGS, "new_Fl_Group(PyObject * _self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Group"},
	 { "delete_Fl_Group", _wrap_delete_Fl_Group, METH_O, "delete_Fl_Group(Fl_Group self)"},
	 { "Fl_Group_add", _wrap_Fl_Group_add, METH_VARARGS, "Fl_Group_add(Fl_Group self, Fl_Widget o)"},
	 { "Fl_Group_insert", _wrap_Fl_Group_insert, METH_VARARGS, "Fl_Group_insert(Fl_Group self, Fl_Widget arg2, int i)"},
	 { "Fl_Group_insert_before", _wrap_Fl_Group_insert_before, METH_VARARGS, "Fl_Group_insert_before(Fl_Group self, Fl_Widget o, Fl_Widget before)"},
	 { "Fl_Group_remove", _wrap_Fl_Group_remove, METH_VARARGS, "\n"
		"Fl_Group_remove(Fl_Group self, int index)\n"
		"Fl_Group_remove(Fl_Group self, Fl_Widget o)\n"
		""},
	 { "Fl_Group_clear", _wrap_Fl_Group_clear, METH_O, "Fl_Group_clear(Fl_Group self)"},
	 { "Fl_Group_delete_child", _wrap_Fl_Group_delete_child, METH_VARARGS, "Fl_Group_delete_child(Fl_Group self, int n) -> int"},
	 { "Fl_Group_resizable", _wrap_Fl_Group_resizable, METH_VARARGS, "\n"
		"Fl_Group_resizable(Fl_Group self, Fl_Widget o)\n"
		"Fl_Group_resizable(Fl_Group self) -> Fl_Widget\n"
		""},
	 { "Fl_Group_add_resizable", _wrap_Fl_Group_add_resizable, METH_VARARGS, "Fl_Group_add_resizable(Fl_Group self, Fl_Widget o)"},
	 { "Fl_Group_init_sizes", _wrap_Fl_Group_init_sizes, METH_O, "Fl_Group_init_sizes(Fl_Group self)"},
	 { "Fl_Group_clip_children", _wrap_Fl_Group_clip_children, METH_VARARGS, "\n"
		"Fl_Group_clip_children(Fl_Group self, int c)\n"
		"Fl_Group_clip_children(Fl_Group self) -> unsigned int\n"
		""},
	 { "Fl_Group_as_group", _wrap_Fl_Group_as_group, METH_VARARGS, "\n"
		"Fl_Group_as_group(Fl_Group self) -> Fl_Group\n"
		"Fl_Group_as_group(Fl_Group self) -> Fl_Group\n"
		""},
	 { "Fl_Group__ddfdesign_kludge", _wrap_Fl_Group__ddfdesign_kludge, METH_O, "Fl_Group__ddfdesign_kludge(Fl_Group self) -> Fl_Widget *&"},
	 { "Fl_Group_init_type", _wrap_Fl_Group_init_type, METH_VARARGS, "Fl_Group_init_type(Fl_Group self, char * Fl_Group)"},
	 { "disown_Fl_Group", _wrap_disown_Fl_Group, METH_O, NULL},
	 { "Fl_Group_swigregister", Fl_Group_swigregister, METH_O, NULL},
	 { "Fl_Group_swiginit", Fl_Group_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_End", _wrap_new_Fl_End, METH_NOARGS, "new_Fl_End() -> Fl_End"},
	 { "delete_Fl_End", _wrap_delete_Fl_End, METH_O, "delete_Fl_End(Fl_End self)"},
	 { "Fl_End_swigregister", Fl_End_swigregister, METH_O, NULL},
	 { "Fl_End_swiginit", Fl_End_swiginit, METH_VARARGS, NULL},
	 { "Fl_Browser__item_first", _wrap_Fl_Browser__item_first, METH_O, "Fl_Browser__item_first(Fl_Browser_ self) -> void *"},
	 { "Fl_Browser__item_next", _wrap_Fl_Browser__item_next, METH_VARARGS, "Fl_Browser__item_next(Fl_Browser_ self, void * item) -> void *"},
	 { "Fl_Browser__item_prev", _wrap_Fl_Browser__item_prev, METH_VARARGS, "Fl_Browser__item_prev(Fl_Browser_ self, void * item) -> void *"},
	 { "Fl_Browser__item_last", _wrap_Fl_Browser__item_last, METH_O, "Fl_Browser__item_last(Fl_Browser_ self) -> void *"},
	 { "Fl_Browser__item_height", _wrap_Fl_Browser__item_height, METH_VARARGS, "Fl_Browser__item_height(Fl_Browser_ self, void * item) -> int"},
	 { "Fl_Browser__item_width", _wrap_Fl_Browser__item_width, METH_VARARGS, "Fl_Browser__item_width(Fl_Browser_ self, void * item) -> int"},
	 { "Fl_Browser__item_quick_height", _wrap_Fl_Browser__item_quick_height, METH_VARARGS, "Fl_Browser__item_quick_height(Fl_Browser_ self, void * item) -> int"},
	 { "Fl_Browser__item_draw", _wrap_Fl_Browser__item_draw, METH_VARARGS, "Fl_Browser__item_draw(Fl_Browser_ self, void * item, int X, int Y, int W, int H)"},
	 { "Fl_Browser__item_text", _wrap_Fl_Browser__item_text, METH_VARARGS, "Fl_Browser__item_text(Fl_Browser_ self, void * item) -> char const *"},
	 { "Fl_Browser__item_swap", _wrap_Fl_Browser__item_swap, METH_VARARGS, "Fl_Browser__item_swap(Fl_Browser_ self, void * a, void * b)"},
	 { "Fl_Browser__item_at", _wrap_Fl_Browser__item_at, METH_VARARGS, "Fl_Browser__item_at(Fl_Browser_ self, int index) -> void *"},
	 { "Fl_Browser__full_width", _wrap_Fl_Browser__full_width, METH_O, "Fl_Browser__full_width(Fl_Browser_ self) -> int"},
	 { "Fl_Browser__full_height", _wrap_Fl_Browser__full_height, METH_O, "Fl_Browser__full_height(Fl_Browser_ self) -> int"},
	 { "Fl_Browser__incr_height", _wrap_Fl_Browser__incr_height, METH_O, "Fl_Browser__incr_height(Fl_Browser_ self) -> int"},
	 { "Fl_Browser__item_select", _wrap_Fl_Browser__item_select, METH_VARARGS, "Fl_Browser__item_select(Fl_Browser_ self, void * item, int val=1)"},
	 { "Fl_Browser__item_selected", _wrap_Fl_Browser__item_selected, METH_VARARGS, "Fl_Browser__item_selected(Fl_Browser_ self, void * item) -> int"},
	 { "Fl_Browser__draw", _wrap_Fl_Browser__draw, METH_O, "Fl_Browser__draw(Fl_Browser_ self)"},
	 { "new_Fl_Browser_", _wrap_new_Fl_Browser_, METH_VARARGS, "new_Fl_Browser_(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Browser_"},
	 { "Fl_Browser__handle", _wrap_Fl_Browser__handle, METH_VARARGS, "Fl_Browser__handle(Fl_Browser_ self, int event) -> int"},
	 { "Fl_Browser__resize", _wrap_Fl_Browser__resize, METH_VARARGS, "Fl_Browser__resize(Fl_Browser_ self, int X, int Y, int W, int H)"},
	 { "Fl_Browser__select", _wrap_Fl_Browser__select, METH_VARARGS, "Fl_Browser__select(Fl_Browser_ self, void * item, int val=1, int docallbacks=0) -> int"},
	 { "Fl_Browser__select_only", _wrap_Fl_Browser__select_only, METH_VARARGS, "Fl_Browser__select_only(Fl_Browser_ self, void * item, int docallbacks=0) -> int"},
	 { "Fl_Browser__deselect", _wrap_Fl_Browser__deselect, METH_VARARGS, "Fl_Browser__deselect(Fl_Browser_ self, int docallbacks=0) -> int"},
	 { "Fl_Browser__vposition", _wrap_Fl_Browser__vposition, METH_VARARGS, "\n"
		"Fl_Browser__vposition(Fl_Browser_ self) -> int\n"
		"Fl_Browser__vposition(Fl_Browser_ self, int pos)\n"
		""},
	 { "Fl_Browser__hposition", _wrap_Fl_Browser__hposition, METH_VARARGS, "\n"
		"Fl_Browser__hposition(Fl_Browser_ self) -> int\n"
		"Fl_Browser__hposition(Fl_Browser_ self, int arg2)\n"
		""},
	 { "Fl_Browser__display", _wrap_Fl_Browser__display, METH_VARARGS, "Fl_Browser__display(Fl_Browser_ self, void * item)"},
	 { "Fl_Browser__has_scrollbar", _wrap_Fl_Browser__has_scrollbar, METH_VARARGS, "\n"
		"Fl_Browser__has_scrollbar(Fl_Browser_ self) -> uchar\n"
		"Fl_Browser__has_scrollbar(Fl_Browser_ self, uchar mode)\n"
		""},
	 { "Fl_Browser__textfont", _wrap_Fl_Browser__textfont, METH_VARARGS, "\n"
		"Fl_Browser__textfont(Fl_Browser_ self) -> Fl_Font\n"
		"Fl_Browser__textfont(Fl_Browser_ self, Fl_Font font)\n"
		""},
	 { "Fl_Browser__textsize", _wrap_Fl_Browser__textsize, METH_VARARGS, "\n"
		"Fl_Browser__textsize(Fl_Browser_ self) -> Fl_Fontsize\n"
		"Fl_Browser__textsize(Fl_Browser_ self, Fl_Fontsize newSize)\n"
		""},
	 { "Fl_Browser__textcolor", _wrap_Fl_Browser__textcolor, METH_VARARGS, "\n"
		"Fl_Browser__textcolor(Fl_Browser_ self) -> Fl_Color\n"
		"Fl_Browser__textcolor(Fl_Browser_ self, Fl_Color col)\n"
		""},
	 { "Fl_Browser__scrollbar_size", _wrap_Fl_Browser__scrollbar_size, METH_VARARGS, "\n"
		"Fl_Browser__scrollbar_size(Fl_Browser_ self) -> int\n"
		"Fl_Browser__scrollbar_size(Fl_Browser_ self, int newSize)\n"
		""},
	 { "Fl_Browser__scrollbar_width", _wrap_Fl_Browser__scrollbar_width, METH_VARARGS, "\n"
		"Fl_Browser__scrollbar_width(Fl_Browser_ self) -> int\n"
		"Fl_Browser__scrollbar_width(Fl_Browser_ self, int width)\n"
		""},
	 { "Fl_Browser__scrollbar_right", _wrap_Fl_Browser__scrollbar_right, METH_O, "Fl_Browser__scrollbar_right(Fl_Browser_ self)"},
	 { "Fl_Browser__scrollbar_left", _wrap_Fl_Browser__scrollbar_left, METH_O, "Fl_Browser__scrollbar_left(Fl_Browser_ self)"},
	 { "Fl_Browser__sort", _wrap_Fl_Browser__sort, METH_VARARGS, "Fl_Browser__sort(Fl_Browser_ self, int flags=0)"},
	 { "Fl_Browser__linespacing", _wrap_Fl_Browser__linespacing, METH_VARARGS, "\n"
		"Fl_Browser__linespacing(Fl_Browser_ self, int pixels)\n"
		"Fl_Browser__linespacing(Fl_Browser_ self) -> int\n"
		""},
	 { "Fl_Browser__init_type", _wrap_Fl_Browser__init_type, METH_VARARGS, "Fl_Browser__init_type(Fl_Browser_ self, char * Fl_Browser_)"},
	 { "Fl_Browser__getScrollbar", _wrap_Fl_Browser__getScrollbar, METH_O, "Fl_Browser__getScrollbar(Fl_Browser_ self) -> Fl_Scrollbar"},
	 { "Fl_Browser__getHScrollbar", _wrap_Fl_Browser__getHScrollbar, METH_O, "Fl_Browser__getHScrollbar(Fl_Browser_ self) -> Fl_Scrollbar"},
	 { "delete_Fl_Browser_", _wrap_delete_Fl_Browser_, METH_O, "delete_Fl_Browser_(Fl_Browser_ self)"},
	 { "disown_Fl_Browser_", _wrap_disown_Fl_Browser_, METH_O, NULL},
	 { "Fl_Browser__swigregister", Fl_Browser__swigregister, METH_O, NULL},
	 { "Fl_Browser__swiginit", Fl_Browser__swiginit, METH_VARARGS, NULL},
	 { "Fl_Browser_item_first", _wrap_Fl_Browser_item_first, METH_O, "Fl_Browser_item_first(Fl_Browser self) -> void *"},
	 { "Fl_Browser_item_next", _wrap_Fl_Browser_item_next, METH_VARARGS, "Fl_Browser_item_next(Fl_Browser self, void * item) -> void *"},
	 { "Fl_Browser_item_prev", _wrap_Fl_Browser_item_prev, METH_VARARGS, "Fl_Browser_item_prev(Fl_Browser self, void * item) -> void *"},
	 { "Fl_Browser_item_last", _wrap_Fl_Browser_item_last, METH_O, "Fl_Browser_item_last(Fl_Browser self) -> void *"},
	 { "Fl_Browser_item_selected", _wrap_Fl_Browser_item_selected, METH_VARARGS, "Fl_Browser_item_selected(Fl_Browser self, void * item) -> int"},
	 { "Fl_Browser_item_select", _wrap_Fl_Browser_item_select, METH_VARARGS, "Fl_Browser_item_select(Fl_Browser self, void * item, int val)"},
	 { "Fl_Browser_item_height", _wrap_Fl_Browser_item_height, METH_VARARGS, "Fl_Browser_item_height(Fl_Browser self, void * item) -> int"},
	 { "Fl_Browser_item_width", _wrap_Fl_Browser_item_width, METH_VARARGS, "Fl_Browser_item_width(Fl_Browser self, void * item) -> int"},
	 { "Fl_Browser_item_draw", _wrap_Fl_Browser_item_draw, METH_VARARGS, "Fl_Browser_item_draw(Fl_Browser self, void * item, int X, int Y, int W, int H)"},
	 { "Fl_Browser_full_height", _wrap_Fl_Browser_full_height, METH_O, "Fl_Browser_full_height(Fl_Browser self) -> int"},
	 { "Fl_Browser_incr_height", _wrap_Fl_Browser_incr_height, METH_O, "Fl_Browser_incr_height(Fl_Browser self) -> int"},
	 { "Fl_Browser_item_text", _wrap_Fl_Browser_item_text, METH_VARARGS, "Fl_Browser_item_text(Fl_Browser self, void * item) -> char const *"},
	 { "Fl_Browser_item_swap", _wrap_Fl_Browser_item_swap, METH_VARARGS, "Fl_Browser_item_swap(Fl_Browser self, void * a, void * b)"},
	 { "Fl_Browser_item_at", _wrap_Fl_Browser_item_at, METH_VARARGS, "Fl_Browser_item_at(Fl_Browser self, int line) -> void *"},
	 { "Fl_Browser_remove", _wrap_Fl_Browser_remove, METH_VARARGS, "Fl_Browser_remove(Fl_Browser self, int line)"},
	 { "Fl_Browser_move", _wrap_Fl_Browser_move, METH_VARARGS, "Fl_Browser_move(Fl_Browser self, int to, int _from)"},
	 { "Fl_Browser_load", _wrap_Fl_Browser_load, METH_VARARGS, "Fl_Browser_load(Fl_Browser self, char const * filename) -> int"},
	 { "Fl_Browser_swap", _wrap_Fl_Browser_swap, METH_VARARGS, "Fl_Browser_swap(Fl_Browser self, int a, int b)"},
	 { "Fl_Browser_clear", _wrap_Fl_Browser_clear, METH_O, "Fl_Browser_clear(Fl_Browser self)"},
	 { "Fl_Browser_size", _wrap_Fl_Browser_size, METH_VARARGS, "\n"
		"Fl_Browser_size(Fl_Browser self) -> int\n"
		"Fl_Browser_size(Fl_Browser self, int W, int H)\n"
		""},
	 { "Fl_Browser_textsize", _wrap_Fl_Browser_textsize, METH_VARARGS, "\n"
		"Fl_Browser_textsize(Fl_Browser self) -> Fl_Fontsize\n"
		"Fl_Browser_textsize(Fl_Browser self, Fl_Fontsize newSize)\n"
		""},
	 { "Fl_Browser_lineposition", _wrap_Fl_Browser_lineposition, METH_VARARGS, "Fl_Browser_lineposition(Fl_Browser self, int line, Fl_Browser::Fl_Line_Position pos)"},
	 { "Fl_Browser_topline", _wrap_Fl_Browser_topline, METH_VARARGS, "\n"
		"Fl_Browser_topline(Fl_Browser self) -> int\n"
		"Fl_Browser_topline(Fl_Browser self, int line)\n"
		""},
	 { "Fl_Browser_bottomline", _wrap_Fl_Browser_bottomline, METH_VARARGS, "Fl_Browser_bottomline(Fl_Browser self, int line)"},
	 { "Fl_Browser_middleline", _wrap_Fl_Browser_middleline, METH_VARARGS, "Fl_Browser_middleline(Fl_Browser self, int line)"},
	 { "Fl_Browser_select", _wrap_Fl_Browser_select, METH_VARARGS, "Fl_Browser_select(Fl_Browser self, int line, int val=1) -> int"},
	 { "Fl_Browser_selected", _wrap_Fl_Browser_selected, METH_VARARGS, "Fl_Browser_selected(Fl_Browser self, int line) -> int"},
	 { "Fl_Browser_show", _wrap_Fl_Browser_show, METH_VARARGS, "\n"
		"Fl_Browser_show(Fl_Browser self, int line)\n"
		"Fl_Browser_show(Fl_Browser self)\n"
		""},
	 { "Fl_Browser_hide", _wrap_Fl_Browser_hide, METH_VARARGS, "\n"
		"Fl_Browser_hide(Fl_Browser self, int line)\n"
		"Fl_Browser_hide(Fl_Browser self)\n"
		""},
	 { "Fl_Browser_visible", _wrap_Fl_Browser_visible, METH_VARARGS, "Fl_Browser_visible(Fl_Browser self, int line) -> int"},
	 { "Fl_Browser_value", _wrap_Fl_Browser_value, METH_VARARGS, "\n"
		"Fl_Browser_value(Fl_Browser self) -> int\n"
		"Fl_Browser_value(Fl_Browser self, int line)\n"
		""},
	 { "Fl_Browser_text", _wrap_Fl_Browser_text, METH_VARARGS, "\n"
		"Fl_Browser_text(Fl_Browser self, int line) -> char const\n"
		"Fl_Browser_text(Fl_Browser self, int line, char const * newtext)\n"
		""},
	 { "new_Fl_Browser", _wrap_new_Fl_Browser, METH_VARARGS, "new_Fl_Browser(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Browser"},
	 { "delete_Fl_Browser", _wrap_delete_Fl_Browser, METH_O, "delete_Fl_Browser(Fl_Browser self)"},
	 { "Fl_Browser_format_char", _wrap_Fl_Browser_format_char, METH_VARARGS, "\n"
		"Fl_Browser_format_char(Fl_Browser self) -> char\n"
		"Fl_Browser_format_char(Fl_Browser self, char c)\n"
		""},
	 { "Fl_Browser_column_char", _wrap_Fl_Browser_column_char, METH_VARARGS, "\n"
		"Fl_Browser_column_char(Fl_Browser self) -> char\n"
		"Fl_Browser_column_char(Fl_Browser self, char c)\n"
		""},
	 { "Fl_Browser_displayed", _wrap_Fl_Browser_displayed, METH_VARARGS, "Fl_Browser_displayed(Fl_Browser self, int line) -> int"},
	 { "Fl_Browser_make_visible", _wrap_Fl_Browser_make_visible, METH_VARARGS, "Fl_Browser_make_visible(Fl_Browser self, int line)"},
	 { "Fl_Browser_icon", _wrap_Fl_Browser_icon, METH_VARARGS, "\n"
		"Fl_Browser_icon(Fl_Browser self, int line, Fl_Image icon)\n"
		"Fl_Browser_icon(Fl_Browser self, int line) -> Fl_Image\n"
		""},
	 { "Fl_Browser_remove_icon", _wrap_Fl_Browser_remove_icon, METH_VARARGS, "Fl_Browser_remove_icon(Fl_Browser self, int line)"},
	 { "Fl_Browser_replace", _wrap_Fl_Browser_replace, METH_VARARGS, "Fl_Browser_replace(Fl_Browser self, int a, char const * b)"},
	 { "Fl_Browser_display", _wrap_Fl_Browser_display, METH_VARARGS, "Fl_Browser_display(Fl_Browser self, int line, int val=1)"},
	 { "Fl_Browser_init_type", _wrap_Fl_Browser_init_type, METH_VARARGS, "Fl_Browser_init_type(Fl_Browser self, char * Fl_Browser)"},
	 { "Fl_Browser_add", _wrap_Fl_Browser_add, METH_VARARGS, "Fl_Browser_add(Fl_Browser self, char const * text, PyObject * data=None)"},
	 { "Fl_Browser_insert", _wrap_Fl_Browser_insert, METH_VARARGS, "Fl_Browser_insert(Fl_Browser self, int index, char const * text, PyObject * data=None)"},
	 { "Fl_Browser_get_data", _wrap_Fl_Browser_get_data, METH_VARARGS, "Fl_Browser_get_data(Fl_Browser self, int index) -> PyObject *"},
	 { "Fl_Browser_data", _wrap_Fl_Browser_data, METH_VARARGS, "Fl_Browser_data(Fl_Browser self, int index, PyObject * data=None) -> PyObject *"},
	 { "Fl_Browser_column_widths", _wrap_Fl_Browser_column_widths, METH_VARARGS, "\n"
		"Fl_Browser_column_widths(Fl_Browser self) -> int const\n"
		"Fl_Browser_column_widths(Fl_Browser self, PyObject * widths)\n"
		""},
	 { "disown_Fl_Browser", _wrap_disown_Fl_Browser, METH_O, NULL},
	 { "Fl_Browser_draw", _wrap_Fl_Browser_draw, METH_O, "Fl_Browser_draw(Fl_Browser self)"},
	 { "Fl_Browser_item_quick_height", _wrap_Fl_Browser_item_quick_height, METH_VARARGS, "Fl_Browser_item_quick_height(Fl_Browser self, void * item) -> int"},
	 { "Fl_Browser_full_width", _wrap_Fl_Browser_full_width, METH_O, "Fl_Browser_full_width(Fl_Browser self) -> int"},
	 { "Fl_Browser_swigregister", Fl_Browser_swigregister, METH_O, NULL},
	 { "Fl_Browser_swiginit", Fl_Browser_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_File_Browser", _wrap_new_Fl_File_Browser, METH_VARARGS, "new_Fl_File_Browser(PyObject * _self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_File_Browser"},
	 { "delete_Fl_File_Browser", _wrap_delete_Fl_File_Browser, METH_O, "delete_Fl_File_Browser(Fl_File_Browser self)"},
	 { "Fl_File_Browser_iconsize", _wrap_Fl_File_Browser_iconsize, METH_VARARGS, "\n"
		"Fl_File_Browser_iconsize(Fl_File_Browser self) -> uchar\n"
		"Fl_File_Browser_iconsize(Fl_File_Browser self, uchar s)\n"
		""},
	 { "Fl_File_Browser_filter", _wrap_Fl_File_Browser_filter, METH_VARARGS, "\n"
		"Fl_File_Browser_filter(Fl_File_Browser self, char const * pattern)\n"
		"Fl_File_Browser_filter(Fl_File_Browser self) -> char const *\n"
		""},
	 { "Fl_File_Browser_textsize", _wrap_Fl_File_Browser_textsize, METH_VARARGS, "\n"
		"Fl_File_Browser_textsize(Fl_File_Browser self) -> Fl_Fontsize\n"
		"Fl_File_Browser_textsize(Fl_File_Browser self, Fl_Fontsize s)\n"
		""},
	 { "Fl_File_Browser_filetype", _wrap_Fl_File_Browser_filetype, METH_VARARGS, "\n"
		"Fl_File_Browser_filetype(Fl_File_Browser self) -> int\n"
		"Fl_File_Browser_filetype(Fl_File_Browser self, int t)\n"
		""},
	 { "Fl_File_Browser_errmsg", _wrap_Fl_File_Browser_errmsg, METH_VARARGS, "\n"
		"Fl_File_Browser_errmsg(Fl_File_Browser self, char const * emsg)\n"
		"Fl_File_Browser_errmsg(Fl_File_Browser self) -> char const *\n"
		""},
	 { "Fl_File_Browser_init_type", _wrap_Fl_File_Browser_init_type, METH_VARARGS, "Fl_File_Browser_init_type(Fl_File_Browser self, char * Fl_File_Browser)"},
	 { "Fl_File_Browser_load", _wrap_Fl_File_Browser_load, METH_VARARGS, "Fl_File_Browser_load(Fl_File_Browser self, PyObject * dObj, PyObject * sObj) -> int"},
	 { "disown_Fl_File_Browser", _wrap_disown_Fl_File_Browser, METH_O, NULL},
	 { "Fl_File_Browser_draw", _wrap_Fl_File_Browser_draw, METH_O, "Fl_File_Browser_draw(Fl_File_Browser self)"},
	 { "Fl_File_Browser_item_first", _wrap_Fl_File_Browser_item_first, METH_O, "Fl_File_Browser_item_first(Fl_File_Browser self) -> void *"},
	 { "Fl_File_Browser_item_next", _wrap_Fl_File_Browser_item_next, METH_VARARGS, "Fl_File_Browser_item_next(Fl_File_Browser self, void * item) -> void *"},
	 { "Fl_File_Browser_item_prev", _wrap_Fl_File_Browser_item_prev, METH_VARARGS, "Fl_File_Browser_item_prev(Fl_File_Browser self, void * item) -> void *"},
	 { "Fl_File_Browser_item_last", _wrap_Fl_File_Browser_item_last, METH_O, "Fl_File_Browser_item_last(Fl_File_Browser self) -> void *"},
	 { "Fl_File_Browser_item_height", _wrap_Fl_File_Browser_item_height, METH_VARARGS, "Fl_File_Browser_item_height(Fl_File_Browser self, void * item) -> int"},
	 { "Fl_File_Browser_item_width", _wrap_Fl_File_Browser_item_width, METH_VARARGS, "Fl_File_Browser_item_width(Fl_File_Browser self, void * item) -> int"},
	 { "Fl_File_Browser_item_quick_height", _wrap_Fl_File_Browser_item_quick_height, METH_VARARGS, "Fl_File_Browser_item_quick_height(Fl_File_Browser self, void * item) -> int"},
	 { "Fl_File_Browser_item_draw", _wrap_Fl_File_Browser_item_draw, METH_VARARGS, "Fl_File_Browser_item_draw(Fl_File_Browser self, void * item, int X, int Y, int W, int H)"},
	 { "Fl_File_Browser_item_text", _wrap_Fl_File_Browser_item_text, METH_VARARGS, "Fl_File_Browser_item_text(Fl_File_Browser self, void * item) -> char const *"},
	 { "Fl_File_Browser_item_swap", _wrap_Fl_File_Browser_item_swap, METH_VARARGS, "Fl_File_Browser_item_swap(Fl_File_Browser self, void * a, void * b)"},
	 { "Fl_File_Browser_item_at", _wrap_Fl_File_Browser_item_at, METH_VARARGS, "Fl_File_Browser_item_at(Fl_File_Browser self, int line) -> void *"},
	 { "Fl_File_Browser_full_width", _wrap_Fl_File_Browser_full_width, METH_O, "Fl_File_Browser_full_width(Fl_File_Browser self) -> int"},
	 { "Fl_File_Browser_full_height", _wrap_Fl_File_Browser_full_height, METH_O, "Fl_File_Browser_full_height(Fl_File_Browser self) -> int"},
	 { "Fl_File_Browser_incr_height", _wrap_Fl_File_Browser_incr_height, METH_O, "Fl_File_Browser_incr_height(Fl_File_Browser self) -> int"},
	 { "Fl_File_Browser_item_select", _wrap_Fl_File_Browser_item_select, METH_VARARGS, "Fl_File_Browser_item_select(Fl_File_Browser self, void * item, int val)"},
	 { "Fl_File_Browser_item_selected", _wrap_Fl_File_Browser_item_selected, METH_VARARGS, "Fl_File_Browser_item_selected(Fl_File_Browser self, void * item) -> int"},
	 { "Fl_File_Browser_swigregister", Fl_File_Browser_swigregister, METH_O, NULL},
	 { "Fl_File_Browser_swiginit", Fl_File_Browser_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_File_Icon", _wrap_new_Fl_File_Icon, METH_VARARGS, "new_Fl_File_Icon(char const * p, int t, int nd=0, short * d=None) -> Fl_File_Icon"},
	 { "delete_Fl_File_Icon", _wrap_delete_Fl_File_Icon, METH_O, "delete_Fl_File_Icon(Fl_File_Icon self)"},
	 { "Fl_File_Icon_add", _wrap_Fl_File_Icon_add, METH_VARARGS, "Fl_File_Icon_add(Fl_File_Icon self, short d) -> short *"},
	 { "Fl_File_Icon_add_color", _wrap_Fl_File_Icon_add_color, METH_VARARGS, "Fl_File_Icon_add_color(Fl_File_Icon self, Fl_Color c) -> short *"},
	 { "Fl_File_Icon_add_vertex", _wrap_Fl_File_Icon_add_vertex, METH_VARARGS, "\n"
		"Fl_File_Icon_add_vertex(Fl_File_Icon self, int x, int y) -> short\n"
		"Fl_File_Icon_add_vertex(Fl_File_Icon self, float x, float y) -> short *\n"
		""},
	 { "Fl_File_Icon_clear", _wrap_Fl_File_Icon_clear, METH_O, "Fl_File_Icon_clear(Fl_File_Icon self)"},
	 { "Fl_File_Icon_draw", _wrap_Fl_File_Icon_draw, METH_VARARGS, "Fl_File_Icon_draw(Fl_File_Icon self, int x, int y, int w, int h, Fl_Color ic, int active=1)"},
	 { "Fl_File_Icon_label", _wrap_Fl_File_Icon_label, METH_VARARGS, "Fl_File_Icon_label(Fl_File_Icon self, Fl_Widget w)"},
	 { "Fl_File_Icon_labeltype", _wrap_Fl_File_Icon_labeltype, METH_VARARGS, "Fl_File_Icon_labeltype(Fl_Label o, int x, int y, int w, int h, Fl_Align a)"},
	 { "Fl_File_Icon_load", _wrap_Fl_File_Icon_load, METH_VARARGS, "Fl_File_Icon_load(Fl_File_Icon self, char const * f)"},
	 { "Fl_File_Icon_load_fti", _wrap_Fl_File_Icon_load_fti, METH_VARARGS, "Fl_File_Icon_load_fti(Fl_File_Icon self, char const * fti) -> int"},
	 { "Fl_File_Icon_load_image", _wrap_Fl_File_Icon_load_image, METH_VARARGS, "Fl_File_Icon_load_image(Fl_File_Icon self, char const * i) -> int"},
	 { "Fl_File_Icon_next", _wrap_Fl_File_Icon_next, METH_O, "Fl_File_Icon_next(Fl_File_Icon self) -> Fl_File_Icon"},
	 { "Fl_File_Icon_pattern", _wrap_Fl_File_Icon_pattern, METH_O, "Fl_File_Icon_pattern(Fl_File_Icon self) -> char const *"},
	 { "Fl_File_Icon_size", _wrap_Fl_File_Icon_size, METH_O, "Fl_File_Icon_size(Fl_File_Icon self) -> int"},
	 { "Fl_File_Icon_type", _wrap_Fl_File_Icon_type, METH_O, "Fl_File_Icon_type(Fl_File_Icon self) -> int"},
	 { "Fl_File_Icon_value", _wrap_Fl_File_Icon_value, METH_O, "Fl_File_Icon_value(Fl_File_Icon self) -> short *"},
	 { "Fl_File_Icon_find", _wrap_Fl_File_Icon_find, METH_VARARGS, "Fl_File_Icon_find(char const * filename, int filetype=ANY) -> Fl_File_Icon"},
	 { "Fl_File_Icon_first", _wrap_Fl_File_Icon_first, METH_NOARGS, "Fl_File_Icon_first() -> Fl_File_Icon"},
	 { "Fl_File_Icon_load_system_icons", _wrap_Fl_File_Icon_load_system_icons, METH_NOARGS, "Fl_File_Icon_load_system_icons()"},
	 { "Fl_File_Icon_swigregister", Fl_File_Icon_swigregister, METH_O, NULL},
	 { "Fl_File_Icon_swiginit", Fl_File_Icon_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_File_Chooser", _wrap_new_Fl_File_Chooser, METH_VARARGS, "new_Fl_File_Chooser(char const * pathname, char const * pattern, int type_val, char const * title) -> Fl_File_Chooser"},
	 { "delete_Fl_File_Chooser", _wrap_delete_Fl_File_Chooser, METH_O, "delete_Fl_File_Chooser(Fl_File_Chooser self)"},
	 { "Fl_File_Chooser_color", _wrap_Fl_File_Chooser_color, METH_VARARGS, "\n"
		"Fl_File_Chooser_color(Fl_File_Chooser self, Fl_Color c)\n"
		"Fl_File_Chooser_color(Fl_File_Chooser self) -> Fl_Color\n"
		""},
	 { "Fl_File_Chooser_count", _wrap_Fl_File_Chooser_count, METH_O, "Fl_File_Chooser_count(Fl_File_Chooser self) -> int"},
	 { "Fl_File_Chooser_directory", _wrap_Fl_File_Chooser_directory, METH_VARARGS, "\n"
		"Fl_File_Chooser_directory(Fl_File_Chooser self, char const * d)\n"
		"Fl_File_Chooser_directory(Fl_File_Chooser self) -> char *\n"
		""},
	 { "Fl_File_Chooser_filter", _wrap_Fl_File_Chooser_filter, METH_VARARGS, "\n"
		"Fl_File_Chooser_filter(Fl_File_Chooser self, char const * p)\n"
		"Fl_File_Chooser_filter(Fl_File_Chooser self) -> char const *\n"
		""},
	 { "Fl_File_Chooser_filter_value", _wrap_Fl_File_Chooser_filter_value, METH_VARARGS, "\n"
		"Fl_File_Chooser_filter_value(Fl_File_Chooser self) -> int\n"
		"Fl_File_Chooser_filter_value(Fl_File_Chooser self, int f)\n"
		""},
	 { "Fl_File_Chooser_iconsize", _wrap_Fl_File_Chooser_iconsize, METH_VARARGS, "\n"
		"Fl_File_Chooser_iconsize(Fl_File_Chooser self, uchar s)\n"
		"Fl_File_Chooser_iconsize(Fl_File_Chooser self) -> uchar\n"
		""},
	 { "Fl_File_Chooser_label", _wrap_Fl_File_Chooser_label, METH_VARARGS, "\n"
		"Fl_File_Chooser_label(Fl_File_Chooser self, char const * l)\n"
		"Fl_File_Chooser_label(Fl_File_Chooser self) -> char const *\n"
		""},
	 { "Fl_File_Chooser_ok_label", _wrap_Fl_File_Chooser_ok_label, METH_VARARGS, "\n"
		"Fl_File_Chooser_ok_label(Fl_File_Chooser self, char const * l)\n"
		"Fl_File_Chooser_ok_label(Fl_File_Chooser self) -> char const *\n"
		""},
	 { "Fl_File_Chooser_preview", _wrap_Fl_File_Chooser_preview, METH_VARARGS, "\n"
		"Fl_File_Chooser_preview(Fl_File_Chooser self, int e)\n"
		"Fl_File_Chooser_preview(Fl_File_Chooser self) -> int\n"
		""},
	 { "Fl_File_Chooser_rescan", _wrap_Fl_File_Chooser_rescan, METH_O, "Fl_File_Chooser_rescan(Fl_File_Chooser self)"},
	 { "Fl_File_Chooser_show", _wrap_Fl_File_Chooser_show, METH_O, "Fl_File_Chooser_show(Fl_File_Chooser self)"},
	 { "Fl_File_Chooser_hide", _wrap_Fl_File_Chooser_hide, METH_O, "Fl_File_Chooser_hide(Fl_File_Chooser self)"},
	 { "Fl_File_Chooser_shown", _wrap_Fl_File_Chooser_shown, METH_O, "Fl_File_Chooser_shown(Fl_File_Chooser self) -> int"},
	 { "Fl_File_Chooser_textcolor", _wrap_Fl_File_Chooser_textcolor, METH_VARARGS, "\n"
		"Fl_File_Chooser_textcolor(Fl_File_Chooser self, Fl_Color c)\n"
		"Fl_File_Chooser_textcolor(Fl_File_Chooser self) -> Fl_Color\n"
		""},
	 { "Fl_File_Chooser_textfont", _wrap_Fl_File_Chooser_textfont, METH_VARARGS, "\n"
		"Fl_File_Chooser_textfont(Fl_File_Chooser self, Fl_Font f)\n"
		"Fl_File_Chooser_textfont(Fl_File_Chooser self) -> Fl_Font\n"
		""},
	 { "Fl_File_Chooser_textsize", _wrap_Fl_File_Chooser_textsize, METH_VARARGS, "\n"
		"Fl_File_Chooser_textsize(Fl_File_Chooser self, Fl_Fontsize s)\n"
		"Fl_File_Chooser_textsize(Fl_File_Chooser self) -> Fl_Fontsize\n"
		""},
	 { "Fl_File_Chooser_type", _wrap_Fl_File_Chooser_type, METH_VARARGS, "\n"
		"Fl_File_Chooser_type(Fl_File_Chooser self, int t)\n"
		"Fl_File_Chooser_type(Fl_File_Chooser self) -> int\n"
		""},
	 { "Fl_File_Chooser_value", _wrap_Fl_File_Chooser_value, METH_VARARGS, "\n"
		"Fl_File_Chooser_value(Fl_File_Chooser self, int f=1) -> char const\n"
		"Fl_File_Chooser_value(Fl_File_Chooser self, char const * filename)\n"
		""},
	 { "Fl_File_Chooser_visible", _wrap_Fl_File_Chooser_visible, METH_O, "Fl_File_Chooser_visible(Fl_File_Chooser self) -> int"},
	 { "Fl_File_Chooser_position", _wrap_Fl_File_Chooser_position, METH_VARARGS, "Fl_File_Chooser_position(Fl_File_Chooser self, int x, int y)"},
	 { "Fl_File_Chooser_x", _wrap_Fl_File_Chooser_x, METH_O, "Fl_File_Chooser_x(Fl_File_Chooser self) -> int"},
	 { "Fl_File_Chooser_y", _wrap_Fl_File_Chooser_y, METH_O, "Fl_File_Chooser_y(Fl_File_Chooser self) -> int"},
	 { "Fl_File_Chooser_w", _wrap_Fl_File_Chooser_w, METH_O, "Fl_File_Chooser_w(Fl_File_Chooser self) -> int"},
	 { "Fl_File_Chooser_h", _wrap_Fl_File_Chooser_h, METH_O, "Fl_File_Chooser_h(Fl_File_Chooser self) -> int"},
	 { "Fl_File_Chooser_size", _wrap_Fl_File_Chooser_size, METH_VARARGS, "Fl_File_Chooser_size(Fl_File_Chooser self, int w, int h)"},
	 { "Fl_File_Chooser_resize", _wrap_Fl_File_Chooser_resize, METH_VARARGS, "Fl_File_Chooser_resize(Fl_File_Chooser self, int x, int y, int w, int h)"},
	 { "Fl_File_Chooser_add_extra", _wrap_Fl_File_Chooser_add_extra, METH_VARARGS, "Fl_File_Chooser_add_extra(Fl_File_Chooser self, Fl_Widget gr) -> Fl_Widget"},
	 { "Fl_File_Chooser_callback", _wrap_Fl_File_Chooser_callback, METH_VARARGS, "\n"
		"Fl_File_Chooser_callback(Fl_File_Chooser self, void (*)(Fl_File_Chooser *,void *) cb, void * d=None)\n"
		"Fl_File_Chooser_callback(Fl_File_Chooser self, PyObject * PyFunc, PyObject * PyWidget, PyObject * PyData=None)\n"
		""},
	 { "Fl_File_Chooser_user_data", _wrap_Fl_File_Chooser_user_data, METH_VARARGS, "\n"
		"Fl_File_Chooser_user_data(Fl_File_Chooser self, PyObject * PyData)\n"
		"Fl_File_Chooser_user_data(Fl_File_Chooser self) -> PyObject *\n"
		""},
	 { "Fl_File_Chooser_swigregister", Fl_File_Chooser_swigregister, METH_O, NULL},
	 { "Fl_File_Chooser_swiginit", Fl_File_Chooser_swiginit, METH_VARARGS, NULL},
	 { "fl_dir_chooser", _wrap_fl_dir_chooser, METH_VARARGS, "fl_dir_chooser(char const * message, char const * fname, int relative=0) -> char *"},
	 { "fl_file_chooser", _wrap_fl_file_chooser, METH_VARARGS, "fl_file_chooser(char const * message, char const * pat, char const * fname, int relative=0) -> char *"},
	 { "fl_file_chooser_callback", _wrap_fl_file_chooser_callback, METH_O, "fl_file_chooser_callback(void (*)(char const *) cb)"},
	 { "fl_file_chooser_ok_label", _wrap_fl_file_chooser_ok_label, METH_O, "fl_file_chooser_ok_label(char const * l)"},
	 { "screen_driver", _wrap_screen_driver, METH_NOARGS, "screen_driver() -> Fl_Screen_Driver *"},
	 { "system_driver", _wrap_system_driver, METH_NOARGS, "system_driver() -> Fl_System_Driver *"},
	 { "box_shadow_width", _wrap_box_shadow_width, METH_VARARGS, "\n"
		"box_shadow_width() -> int\n"
		"box_shadow_width(int W)\n"
		""},
	 { "box_border_radius_max", _wrap_box_border_radius_max, METH_VARARGS, "\n"
		"box_border_radius_max() -> int\n"
		"box_border_radius_max(int R)\n"
		""},
	 { "call_screen_init", _wrap_call_screen_init, METH_NOARGS, "call_screen_init()"},
	 { "idle", _wrap_idle, METH_NOARGS, "idle() -> bool"},
	 { "version", _wrap_version, METH_NOARGS, "version() -> double"},
	 { "api_version", _wrap_api_version, METH_NOARGS, "api_version() -> int"},
	 { "abi_version", _wrap_abi_version, METH_NOARGS, "abi_version() -> int"},
	 { "abi_check", _wrap_abi_check, METH_VARARGS, "abi_check(int const val=FL_ABI_VERSION) -> int"},
	 { "arg", _wrap_arg, METH_VARARGS, "arg(int argc, char ** argv, int & i) -> int"},
	 { "args", _wrap_args, METH_VARARGS, "\n"
		"args(int argc, char ** argv, int & i, Fl_Args_Handler cb=0) -> int\n"
		"args(int argc, char ** argv)\n"
		""},
	 { "display", _wrap_display, METH_O, "display(char const * arg1)"},
	 { "visual", _wrap_visual, METH_O, "visual(int arg1) -> int"},
	 { "own_colormap", _wrap_own_colormap, METH_NOARGS, "own_colormap()"},
	 { "get_system_colors", _wrap_get_system_colors, METH_NOARGS, "get_system_colors()"},
	 { "foreground", _wrap_foreground, METH_VARARGS, "foreground(uchar arg1, uchar arg2, uchar arg3)"},
	 { "background", _wrap_background, METH_VARARGS, "background(uchar arg1, uchar arg2, uchar arg3)"},
	 { "background2", _wrap_background2, METH_VARARGS, "background2(uchar arg1, uchar arg2, uchar arg3)"},
	 { "scheme", _wrap_scheme, METH_VARARGS, "\n"
		"scheme(char const * name) -> int\n"
		"scheme() -> char const *\n"
		""},
	 { "is_scheme", _wrap_is_scheme, METH_O, "is_scheme(char const * name) -> int"},
	 { "reload_scheme", _wrap_reload_scheme, METH_NOARGS, "reload_scheme() -> int"},
	 { "scrollbar_size", _wrap_scrollbar_size, METH_VARARGS, "\n"
		"scrollbar_size() -> int\n"
		"scrollbar_size(int W)\n"
		""},
	 { "menu_linespacing", _wrap_menu_linespacing, METH_VARARGS, "\n"
		"menu_linespacing() -> int\n"
		"menu_linespacing(int H)\n"
		""},
	 { "wait", _wrap_wait, METH_VARARGS, "\n"
		"wait() -> int\n"
		"wait(double time) -> double\n"
		""},
	 { "check", _wrap_check, METH_NOARGS, "check() -> int"},
	 { "ready", _wrap_ready, METH_NOARGS, "ready() -> int"},
	 { "run", _wrap_run, METH_NOARGS, "run() -> int"},
	 { "program_should_quit", _wrap_program_should_quit, METH_VARARGS, "\n"
		"program_should_quit() -> int\n"
		"program_should_quit(int should_i)\n"
		""},
	 { "hide_all_windows", _wrap_hide_all_windows, METH_NOARGS, "hide_all_windows()"},
	 { "readqueue", _wrap_readqueue, METH_NOARGS, "readqueue() -> Fl_Widget"},
	 { "has_timeout", _wrap_has_timeout, METH_VARARGS, "has_timeout(Fl_Timeout_Handler cb, void * data=None) -> int"},
	 { "remove_next_timeout", _wrap_remove_next_timeout, METH_VARARGS, "remove_next_timeout(Fl_Timeout_Handler cb, void * data=None, void ** data_return=None) -> int"},
	 { "new_TimeoutData", _wrap_new_TimeoutData, METH_NOARGS, "new_TimeoutData() -> Fl::TimeoutData *"},
	 { "delete_TimeoutData", _wrap_delete_TimeoutData, METH_O, "delete_TimeoutData(TimeoutData self)"},
	 { "TimeoutData_swigregister", TimeoutData_swigregister, METH_O, NULL},
	 { "TimeoutData_swiginit", TimeoutData_swiginit, METH_VARARGS, NULL},
	 { "timeout_list", _wrap_timeout_list, METH_NOARGS, "timeout_list() -> std::vector< Fl::TimeoutData >"},
	 { "now", _wrap_now, METH_VARARGS, "now(double offset=0) -> Fl_Timestamp"},
	 { "seconds_since", _wrap_seconds_since, METH_O, "seconds_since(Fl_Timestamp & then) -> double"},
	 { "seconds_between", _wrap_seconds_between, METH_VARARGS, "seconds_between(Fl_Timestamp & back, Fl_Timestamp & further_back) -> double"},
	 { "ticks_since", _wrap_ticks_since, METH_O, "ticks_since(Fl_Timestamp & then) -> long"},
	 { "ticks_between", _wrap_ticks_between, METH_VARARGS, "ticks_between(Fl_Timestamp & back, Fl_Timestamp & further_back) -> long"},
	 { "has_idle", _wrap_has_idle, METH_VARARGS, "has_idle(Fl_Idle_Handler cb, void * data=None) -> int"},
	 { "remove_idle", _wrap_remove_idle, METH_VARARGS, "remove_idle(Fl_Idle_Handler cb, void * data=None)"},
	 { "add_idle", _wrap_add_idle, METH_VARARGS, "\n"
		"add_idle(Fl_Idle_Handler cb, void * data=None)\n"
		"add_idle(Fl_Old_Idle_Handler cb)\n"
		""},
	 { "damage", _wrap_damage, METH_VARARGS, "\n"
		"damage(int d)\n"
		"damage() -> int\n"
		""},
	 { "redraw", _wrap_redraw, METH_NOARGS, "redraw()"},
	 { "flush", _wrap_flush, METH_NOARGS, "flush()"},
	 { "first_window", _wrap_first_window, METH_VARARGS, "\n"
		"first_window() -> Fl_Window\n"
		"first_window(Fl_Window arg1)\n"
		""},
	 { "next_window", _wrap_next_window, METH_O, "next_window(Fl_Window arg1) -> Fl_Window"},
	 { "modal", _wrap_modal, METH_NOARGS, "modal() -> Fl_Window"},
	 { "grab", _wrap_grab, METH_VARARGS, "\n"
		"grab() -> Fl_Window\n"
		"grab(Fl_Window arg1)\n"
		""},
	 { "copy", _wrap_copy, METH_VARARGS, "copy(char const * stuff, int len, int destination=0, char const * type=Fl::clipboard_plain_text)"},
	 { "selection_to_clipboard", _wrap_selection_to_clipboard, METH_VARARGS, "\n"
		"selection_to_clipboard(int mode)\n"
		"selection_to_clipboard() -> int\n"
		""},
	 { "add_clipboard_notify", _wrap_add_clipboard_notify, METH_VARARGS, "add_clipboard_notify(Fl_Clipboard_Notify_Handler h, void * data=None)"},
	 { "remove_clipboard_notify", _wrap_remove_clipboard_notify, METH_O, "remove_clipboard_notify(Fl_Clipboard_Notify_Handler h)"},
	 { "clipboard_contains", _wrap_clipboard_contains, METH_O, "clipboard_contains(char const * type) -> int"},
	 { "dnd", _wrap_dnd, METH_NOARGS, "dnd() -> int"},
	 { "selection_owner", _wrap_selection_owner, METH_VARARGS, "\n"
		"selection_owner() -> Fl_Widget\n"
		"selection_owner(Fl_Widget arg1)\n"
		""},
	 { "selection", _wrap_selection, METH_VARARGS, "selection(Fl_Widget owner, char const * arg2, int len)"},
	 { "paste", _wrap_paste, METH_VARARGS, "\n"
		"paste(Fl_Widget receiver, int source, char const * type=Fl::clipboard_plain_text)\n"
		"paste(Fl_Widget receiver)\n"
		""},
	 { "x", _wrap_x, METH_NOARGS, "x() -> int"},
	 { "y", _wrap_y, METH_NOARGS, "y() -> int"},
	 { "w", _wrap_w, METH_NOARGS, "w() -> int"},
	 { "h", _wrap_h, METH_NOARGS, "h() -> int"},
	 { "screen_count", _wrap_screen_count, METH_NOARGS, "screen_count() -> int"},
	 { "screen_xywh", _wrap_screen_xywh, METH_VARARGS, "\n"
		"screen_xywh()\n"
		"screen_xywh(int mx, int my)\n"
		"screen_xywh(int n)\n"
		"screen_xywh(int mx, int my, int mw, int mh)\n"
		""},
	 { "screen_num", _wrap_screen_num, METH_VARARGS, "\n"
		"screen_num(int x, int y) -> int\n"
		"screen_num(int x, int y, int w, int h) -> int\n"
		""},
	 { "screen_dpi", _wrap_screen_dpi, METH_VARARGS, "screen_dpi(float & h, float & v, int n=0)"},
	 { "screen_work_area", _wrap_screen_work_area, METH_VARARGS, "\n"
		"screen_work_area(int mx, int my)\n"
		"screen_work_area(int n)\n"
		"screen_work_area()\n"
		""},
	 { "screen_scale", _wrap_screen_scale, METH_VARARGS, "\n"
		"screen_scale(int n) -> float\n"
		"screen_scale(int n, float factor)\n"
		""},
	 { "screen_scaling_supported", _wrap_screen_scaling_supported, METH_NOARGS, "screen_scaling_supported() -> int"},
	 { "keyboard_screen_scaling", _wrap_keyboard_screen_scaling, METH_O, "keyboard_screen_scaling(int value)"},
	 { "set_color", _wrap_set_color, METH_VARARGS, "\n"
		"set_color(Fl_Color arg1, uchar arg2, uchar arg3, uchar arg4)\n"
		"set_color(Fl_Color arg1, uchar arg2, uchar arg3, uchar arg4, uchar arg5)\n"
		"set_color(Fl_Color i, unsigned int c)\n"
		""},
	 { "get_color", _wrap_get_color, METH_VARARGS, "\n"
		"get_color(Fl_Color i)\n"
		"get_color(Fl_Color i)\n"
		""},
	 { "free_color", _wrap_free_color, METH_VARARGS, "free_color(Fl_Color i, int overlay=0)"},
	 { "get_font", _wrap_get_font, METH_O, "get_font(Fl_Font arg1) -> char const *"},
	 { "get_font_name", _wrap_get_font_name, METH_O, "get_font_name(Fl_Font arg1) -> char const *"},
	 { "set_font", _wrap_set_font, METH_VARARGS, "\n"
		"set_font(Fl_Font arg1, char const * arg2)\n"
		"set_font(Fl_Font arg1, Fl_Font arg2)\n"
		""},
	 { "set_fonts", _wrap_set_fonts, METH_VARARGS, "set_fonts(char const * arg1=None) -> Fl_Font"},
	 { "set_labeltype", _wrap_set_labeltype, METH_VARARGS, "set_labeltype(Fl_Labeltype arg1, Fl_Label_Draw_F * arg2, Fl_Label_Measure_F * arg3)"},
	 { "get_boxtype", _wrap_get_boxtype, METH_O, "get_boxtype(Fl_Boxtype arg1) -> Fl_Box_Draw_F *"},
	 { "set_boxtype", _wrap_set_boxtype, METH_VARARGS, "\n"
		"set_boxtype(Fl_Boxtype arg1, Fl_Box_Draw_F * arg2, uchar arg3, uchar arg4, uchar arg5, uchar arg6, Fl_Box_Draw_Focus_F * arg7=None)\n"
		"set_boxtype(Fl_Boxtype arg1, Fl_Boxtype _from)\n"
		""},
	 { "box_dx", _wrap_box_dx, METH_O, "box_dx(Fl_Boxtype arg1) -> int"},
	 { "box_dy", _wrap_box_dy, METH_O, "box_dy(Fl_Boxtype arg1) -> int"},
	 { "box_dw", _wrap_box_dw, METH_O, "box_dw(Fl_Boxtype arg1) -> int"},
	 { "box_dh", _wrap_box_dh, METH_O, "box_dh(Fl_Boxtype arg1) -> int"},
	 { "draw_box_active", _wrap_draw_box_active, METH_NOARGS, "draw_box_active() -> int"},
	 { "box_color", _wrap_box_color, METH_O, "box_color(Fl_Color arg1) -> Fl_Color"},
	 { "set_box_color", _wrap_set_box_color, METH_O, "set_box_color(Fl_Color arg1)"},
	 { "set_abort", _wrap_set_abort, METH_O, "set_abort(Fl_Abort_Handler f)"},
	 { "default_atclose", _wrap_default_atclose, METH_VARARGS, "default_atclose(Fl_Window arg1, void * arg2)"},
	 { "set_atclose", _wrap_set_atclose, METH_O, "set_atclose(Fl_Atclose_Handler f)"},
	 { "use_high_res_VK", _wrap_use_high_res_VK, METH_VARARGS, "\n"
		"use_high_res_VK(int val)\n"
		"use_high_res_VK() -> int\n"
		""},
	 { "lock", _wrap_lock, METH_NOARGS, "lock() -> int"},
	 { "unlock", _wrap_unlock, METH_NOARGS, "unlock()"},
	 { "awake", _wrap_awake, METH_VARARGS, "\n"
		"awake()\n"
		"awake(void * message)\n"
		"awake(Fl_Awake_Handler handler, void * user_data=None) -> int\n"
		""},
	 { "awake_once", _wrap_awake_once, METH_VARARGS, "awake_once(Fl_Awake_Handler handler, void * user_data=None) -> int"},
	 { "thread_message", _wrap_thread_message, METH_NOARGS, "thread_message() -> void *"},
	 { "use_high_res_GL", _wrap_use_high_res_GL, METH_VARARGS, "\n"
		"use_high_res_GL(int val)\n"
		"use_high_res_GL() -> int\n"
		""},
	 { "draw_GL_text_with_textures", _wrap_draw_GL_text_with_textures, METH_VARARGS, "\n"
		"draw_GL_text_with_textures(int val)\n"
		"draw_GL_text_with_textures() -> int\n"
		""},
	 { "system", _wrap_system, METH_O, "system(char const * command) -> int"},
	 { "args_to_utf8", _wrap_args_to_utf8, METH_VARARGS, "args_to_utf8(int argc, char **& argv) -> int"},
	 { "pyFLTK_controlIdleCallbacks", _wrap_pyFLTK_controlIdleCallbacks, METH_O, "pyFLTK_controlIdleCallbacks(int enable)"},
	 { "pyFLTK_registerDoIdle", registerDoIdle, METH_VARARGS, NULL},
	 { "Fl_add_timeout", Fl_add_timeout, METH_VARARGS, NULL},
	 { "Fl_repeat_timeout", Fl_repeat_timeout, METH_VARARGS, NULL},
	 { "Fl_remove_timeout", Fl_remove_timeout, METH_VARARGS, NULL},
	 { "Fl_add_fd", Fl_add_fd, METH_VARARGS, NULL},
	 { "Fl_remove_fd", Fl_remove_fd, METH_VARARGS, NULL},
	 { "Fl_add_handler", Fl_add_handler, METH_VARARGS, NULL},
	 { "Fl_remove_handler", Fl_remove_handler, METH_VARARGS, NULL},
	 { "Fl_add_check", Fl_add_check, METH_VARARGS, NULL},
	 { "Fl_remove_check", Fl_remove_check, METH_VARARGS, NULL},
	 { "Fl_get_font_sizes_tmp", Fl_get_font_sizes_tmp, METH_VARARGS, NULL},
	 { "fl_filename_name", _wrap_fl_filename_name, METH_O, "fl_filename_name(char const * filename) -> char const *"},
	 { "fl_filename_ext", _wrap_fl_filename_ext, METH_O, "fl_filename_ext(char const * buf) -> char const *"},
	 { "fl_filename_match", _wrap_fl_filename_match, METH_VARARGS, "fl_filename_match(char const * name, char const * pattern) -> int"},
	 { "fl_filename_isdir", _wrap_fl_filename_isdir, METH_O, "fl_filename_isdir(char const * name) -> int"},
	 { "fl_filename_name_str", _wrap_fl_filename_name_str, METH_O, "fl_filename_name_str(std::string const & filename) -> std::string"},
	 { "fl_filename_path_str", _wrap_fl_filename_path_str, METH_O, "fl_filename_path_str(std::string const & filename) -> std::string"},
	 { "fl_filename_ext_str", _wrap_fl_filename_ext_str, METH_O, "fl_filename_ext_str(std::string const & filename) -> std::string"},
	 { "fl_filename_setext_str", _wrap_fl_filename_setext_str, METH_VARARGS, "fl_filename_setext_str(std::string const & filename, std::string const & new_extension) -> std::string"},
	 { "fl_filename_expand_str", _wrap_fl_filename_expand_str, METH_O, "fl_filename_expand_str(std::string const & _from) -> std::string"},
	 { "fl_filename_absolute_str", _wrap_fl_filename_absolute_str, METH_VARARGS, "\n"
		"fl_filename_absolute_str(std::string const & _from) -> std::string\n"
		"fl_filename_absolute_str(std::string const & _from, std::string const & base) -> std::string\n"
		""},
	 { "fl_filename_relative_str", _wrap_fl_filename_relative_str, METH_VARARGS, "\n"
		"fl_filename_relative_str(std::string const & _from) -> std::string\n"
		"fl_filename_relative_str(std::string const & _from, std::string const & base) -> std::string\n"
		""},
	 { "fl_getcwd_str", _wrap_fl_getcwd_str, METH_NOARGS, "fl_getcwd_str() -> std::string"},
	 { "fl_filename_setext", _wrap_fl_filename_setext, METH_VARARGS, "\n"
		"fl_filename_setext(char * to, int tolen, char const * ext) -> char\n"
		"fl_filename_setext(char * to, char const * ext) -> char *\n"
		""},
	 { "fl_filename_expand", _wrap_fl_filename_expand, METH_VARARGS, "\n"
		"fl_filename_expand(char * to, int tolen, char const * _from) -> int\n"
		"fl_filename_expand(char * to, char const * _from) -> int\n"
		""},
	 { "fl_filename_absolute", _wrap_fl_filename_absolute, METH_VARARGS, "\n"
		"fl_filename_absolute(char * to, int tolen, char const * _from) -> int\n"
		"fl_filename_absolute(char * to, int tolen, char const * _from, char const * cwd) -> int\n"
		"fl_filename_absolute(char * to, char const * _from) -> int\n"
		""},
	 { "fl_filename_relative", _wrap_fl_filename_relative, METH_VARARGS, "\n"
		"fl_filename_relative(char * to, int tolen, char const * _from) -> int\n"
		"fl_filename_relative(char * to, int tolen, char const * _from, char const * cwd) -> int\n"
		"fl_filename_relative(char * to, char const * _from) -> int\n"
		""},
	 { "fl_filename_free_list", _wrap_fl_filename_free_list, METH_VARARGS, "fl_filename_free_list(dirent *** l, int n)"},
	 { "fl_open_uri", _wrap_fl_open_uri, METH_VARARGS, "fl_open_uri(char const * uri, char * msg=(char *) 0, int msglen=0) -> int"},
	 { "fl_decode_uri", _wrap_fl_decode_uri, METH_O, "fl_decode_uri(char * uri)"},
	 { "new_Fl_Valuator", _wrap_new_Fl_Valuator, METH_VARARGS, "new_Fl_Valuator(PyObject * _self, int X, int Y, int W, int H, char const * L) -> Fl_Valuator"},
	 { "delete_Fl_Valuator", _wrap_delete_Fl_Valuator, METH_O, "delete_Fl_Valuator(Fl_Valuator self)"},
	 { "Fl_Valuator_bounds", _wrap_Fl_Valuator_bounds, METH_VARARGS, "Fl_Valuator_bounds(Fl_Valuator self, double a, double b)"},
	 { "Fl_Valuator_minimum", _wrap_Fl_Valuator_minimum, METH_VARARGS, "\n"
		"Fl_Valuator_minimum(Fl_Valuator self) -> double\n"
		"Fl_Valuator_minimum(Fl_Valuator self, double a)\n"
		""},
	 { "Fl_Valuator_maximum", _wrap_Fl_Valuator_maximum, METH_VARARGS, "\n"
		"Fl_Valuator_maximum(Fl_Valuator self) -> double\n"
		"Fl_Valuator_maximum(Fl_Valuator self, double a)\n"
		""},
	 { "Fl_Valuator_range", _wrap_Fl_Valuator_range, METH_VARARGS, "Fl_Valuator_range(Fl_Valuator self, double a, double b)"},
	 { "Fl_Valuator_step", _wrap_Fl_Valuator_step, METH_VARARGS, "\n"
		"Fl_Valuator_step(Fl_Valuator self, int a)\n"
		"Fl_Valuator_step(Fl_Valuator self, double a, int b)\n"
		"Fl_Valuator_step(Fl_Valuator self, double s)\n"
		"Fl_Valuator_step(Fl_Valuator self) -> double\n"
		""},
	 { "Fl_Valuator_precision", _wrap_Fl_Valuator_precision, METH_VARARGS, "Fl_Valuator_precision(Fl_Valuator self, int arg2)"},
	 { "Fl_Valuator_value", _wrap_Fl_Valuator_value, METH_VARARGS, "\n"
		"Fl_Valuator_value(Fl_Valuator self) -> double\n"
		"Fl_Valuator_value(Fl_Valuator self, double arg2) -> int\n"
		""},
	 { "Fl_Valuator_format", _wrap_Fl_Valuator_format, METH_VARARGS, "Fl_Valuator_format(Fl_Valuator self, char * format_string) -> int"},
	 { "Fl_Valuator_round", _wrap_Fl_Valuator_round, METH_VARARGS, "Fl_Valuator_round(Fl_Valuator self, double arg2) -> double"},
	 { "Fl_Valuator_clamp", _wrap_Fl_Valuator_clamp, METH_VARARGS, "Fl_Valuator_clamp(Fl_Valuator self, double arg2) -> double"},
	 { "Fl_Valuator_increment", _wrap_Fl_Valuator_increment, METH_VARARGS, "Fl_Valuator_increment(Fl_Valuator self, double arg2, int arg3) -> double"},
	 { "Fl_Valuator_init_type", _wrap_Fl_Valuator_init_type, METH_VARARGS, "Fl_Valuator_init_type(Fl_Valuator self, char * Fl_Valuator)"},
	 { "disown_Fl_Valuator", _wrap_disown_Fl_Valuator, METH_O, NULL},
	 { "Fl_Valuator_swigregister", Fl_Valuator_swigregister, METH_O, NULL},
	 { "Fl_Valuator_swiginit", Fl_Valuator_swiginit, METH_VARARGS, NULL},
	 { "Fl_Adjuster_draw", _wrap_Fl_Adjuster_draw, METH_O, "Fl_Adjuster_draw(Fl_Adjuster self)"},
	 { "Fl_Adjuster_handle", _wrap_Fl_Adjuster_handle, METH_VARARGS, "Fl_Adjuster_handle(Fl_Adjuster self, int arg0) -> int"},
	 { "new_Fl_Adjuster", _wrap_new_Fl_Adjuster, METH_VARARGS, "new_Fl_Adjuster(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Adjuster"},
	 { "Fl_Adjuster_soft", _wrap_Fl_Adjuster_soft, METH_VARARGS, "\n"
		"Fl_Adjuster_soft(Fl_Adjuster self, int s)\n"
		"Fl_Adjuster_soft(Fl_Adjuster self) -> int\n"
		""},
	 { "Fl_Adjuster_init_type", _wrap_Fl_Adjuster_init_type, METH_VARARGS, "Fl_Adjuster_init_type(Fl_Adjuster self, char * Fl_Adjuster)"},
	 { "delete_Fl_Adjuster", _wrap_delete_Fl_Adjuster, METH_O, "delete_Fl_Adjuster(Fl_Adjuster self)"},
	 { "disown_Fl_Adjuster", _wrap_disown_Fl_Adjuster, METH_O, NULL},
	 { "Fl_Adjuster_swigregister", Fl_Adjuster_swigregister, METH_O, NULL},
	 { "Fl_Adjuster_swiginit", Fl_Adjuster_swiginit, METH_VARARGS, NULL},
	 { "fl_beep", _wrap_fl_beep, METH_VARARGS, "fl_beep(int type=FL_BEEP_DEFAULT)"},
	 { "fl_message", _wrap_fl_message, METH_VARARGS, "fl_message(char const * arg1)"},
	 { "fl_alert", _wrap_fl_alert, METH_VARARGS, "fl_alert(char const * arg1)"},
	 { "fl_ask", _wrap_fl_ask, METH_VARARGS, "fl_ask(char const * arg1) -> int"},
	 { "fl_choice", _wrap_fl_choice, METH_VARARGS, "fl_choice(char const * q, char const * b0, char const * b1, char const * b2) -> int"},
	 { "fl_choice_n", _wrap_fl_choice_n, METH_VARARGS, "fl_choice_n(char const * q, char const * b0, char const * b1, char const * b2) -> int"},
	 { "fl_message_icon", _wrap_fl_message_icon, METH_NOARGS, "fl_message_icon() -> Fl_Widget"},
	 { "fl_message_font", _wrap_fl_message_font, METH_VARARGS, "fl_message_font(Fl_Font f, Fl_Fontsize s)"},
	 { "fl_message_hotspot", _wrap_fl_message_hotspot, METH_VARARGS, "\n"
		"fl_message_hotspot(int enable)\n"
		"fl_message_hotspot() -> int\n"
		""},
	 { "fl_message_position", _wrap_fl_message_position, METH_VARARGS, "\n"
		"fl_message_position(int const x, int const y, int const center=0)\n"
		"fl_message_position(Fl_Widget widget)\n"
		"fl_message_position(int * x=None, int * y=None) -> int\n"
		"fl_message_position(Fl_Widget widget)\n"
		""},
	 { "fl_message_title", _wrap_fl_message_title, METH_O, "fl_message_title(char const * title)"},
	 { "fl_message_title_default", _wrap_fl_message_title_default, METH_O, "fl_message_title_default(char const * title)"},
	 { "fl_message_icon_label", _wrap_fl_message_icon_label, METH_O, "fl_message_icon_label(char const * str)"},
	 { "fl_input", _wrap_fl_input, METH_VARARGS, "fl_input(char const * label, char const * deflt=None) -> char const *"},
	 { "fl_password", _wrap_fl_password, METH_VARARGS, "fl_password(char const * label, char const * deflt=None) -> char const *"},
	 { "fl_no_get", _wrap_fl_no_get, METH_NOARGS, "fl_no_get() -> char const *"},
	 { "fl_yes_get", _wrap_fl_yes_get, METH_NOARGS, "fl_yes_get() -> char const *"},
	 { "fl_ok_get", _wrap_fl_ok_get, METH_NOARGS, "fl_ok_get() -> char const *"},
	 { "fl_cancel_get", _wrap_fl_cancel_get, METH_NOARGS, "fl_cancel_get() -> char const *"},
	 { "fl_close_get", _wrap_fl_close_get, METH_NOARGS, "fl_close_get() -> char const *"},
	 { "fl_no_set", _wrap_fl_no_set, METH_O, "fl_no_set(char const * value)"},
	 { "fl_yes_set", _wrap_fl_yes_set, METH_O, "fl_yes_set(char const * value)"},
	 { "fl_ok_set", _wrap_fl_ok_set, METH_O, "fl_ok_set(char const * value)"},
	 { "fl_cancel_set", _wrap_fl_cancel_set, METH_O, "fl_cancel_set(char const * value)"},
	 { "fl_close_set", _wrap_fl_close_set, METH_O, "fl_close_set(char const * value)"},
	 { "fl_mt_message", _wrap_fl_mt_message, METH_O, "fl_mt_message(char const * text)"},
	 { "fl_mt_alert", _wrap_fl_mt_alert, METH_O, "fl_mt_alert(char const * text)"},
	 { "fl_mt_choice", _wrap_fl_mt_choice, METH_VARARGS, "fl_mt_choice(char const * q, char const * b0, char const * b1, char const * b2) -> int"},
	 { "fl_mt_input", _wrap_fl_mt_input, METH_VARARGS, "fl_mt_input(char const * label, char const * deflt=None) -> char const *"},
	 { "fl_mt_password", _wrap_fl_mt_password, METH_VARARGS, "fl_mt_password(char const * label, char const * deflt=None) -> char const *"},
	 { "new_Fl_Bitmap", _wrap_new_Fl_Bitmap, METH_VARARGS, "\n"
		"Fl_Bitmap(uchar const * bits, int W, int H)\n"
		"Fl_Bitmap(uchar const * bits, int bits_length, int W, int H)\n"
		"new_Fl_Bitmap(PyObject * _self, char const * bits, int bits_length, int W, int H) -> Fl_Bitmap\n"
		""},
	 { "delete_Fl_Bitmap", _wrap_delete_Fl_Bitmap, METH_O, "delete_Fl_Bitmap(Fl_Bitmap self)"},
	 { "Fl_Bitmap_copy", _wrap_Fl_Bitmap_copy, METH_VARARGS, "\n"
		"Fl_Bitmap_copy(Fl_Bitmap self, int W, int H) -> Fl_Image\n"
		"Fl_Bitmap_copy(Fl_Bitmap self) -> Fl_Image\n"
		""},
	 { "Fl_Bitmap_draw", _wrap_Fl_Bitmap_draw, METH_VARARGS, "\n"
		"Fl_Bitmap_draw(Fl_Bitmap self, int X, int Y, int W, int H, int cx=0, int cy=0)\n"
		"Fl_Bitmap_draw(Fl_Bitmap self, int X, int Y)\n"
		""},
	 { "Fl_Bitmap_label", _wrap_Fl_Bitmap_label, METH_VARARGS, "\n"
		"Fl_Bitmap_label(Fl_Bitmap self, Fl_Widget w)\n"
		"Fl_Bitmap_label(Fl_Bitmap self, Fl_Menu_Item m)\n"
		""},
	 { "Fl_Bitmap_uncache", _wrap_Fl_Bitmap_uncache, METH_O, "Fl_Bitmap_uncache(Fl_Bitmap self)"},
	 { "Fl_Bitmap_cache_w", _wrap_Fl_Bitmap_cache_w, METH_O, "Fl_Bitmap_cache_w(Fl_Bitmap self) -> int"},
	 { "Fl_Bitmap_cache_h", _wrap_Fl_Bitmap_cache_h, METH_O, "Fl_Bitmap_cache_h(Fl_Bitmap self) -> int"},
	 { "disown_Fl_Bitmap", _wrap_disown_Fl_Bitmap, METH_O, NULL},
	 { "Fl_Bitmap_swigregister", Fl_Bitmap_swigregister, METH_O, NULL},
	 { "Fl_Bitmap_swiginit", Fl_Bitmap_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_BMP_Image", _wrap_new_Fl_BMP_Image, METH_VARARGS, "\n"
		"Fl_BMP_Image(char const * filename)\n"
		"new_Fl_BMP_Image(PyObject * _self, char const * imagename, unsigned char const * data, long const length=-1) -> Fl_BMP_Image\n"
		""},
	 { "delete_Fl_BMP_Image", _wrap_delete_Fl_BMP_Image, METH_O, "delete_Fl_BMP_Image(Fl_BMP_Image self)"},
	 { "disown_Fl_BMP_Image", _wrap_disown_Fl_BMP_Image, METH_O, NULL},
	 { "Fl_BMP_Image_swigregister", Fl_BMP_Image_swigregister, METH_O, NULL},
	 { "Fl_BMP_Image_swiginit", Fl_BMP_Image_swiginit, METH_VARARGS, NULL},
	 { "Fl_Box_draw", _wrap_Fl_Box_draw, METH_O, "Fl_Box_draw(Fl_Box self)"},
	 { "new_Fl_Box", _wrap_new_Fl_Box, METH_VARARGS, "\n"
		"Fl_Box(int X, int Y, int W, int H, char const * L=None)\n"
		"new_Fl_Box(PyObject * _self, Fl_Boxtype B, int X, int Y, int W, int H, char const * L) -> Fl_Box\n"
		""},
	 { "Fl_Box_handle", _wrap_Fl_Box_handle, METH_VARARGS, "Fl_Box_handle(Fl_Box self, int arg0) -> int"},
	 { "Fl_Box_init_type", _wrap_Fl_Box_init_type, METH_VARARGS, "Fl_Box_init_type(Fl_Box self, char * Fl_Box)"},
	 { "delete_Fl_Box", _wrap_delete_Fl_Box, METH_O, "delete_Fl_Box(Fl_Box self)"},
	 { "disown_Fl_Box", _wrap_disown_Fl_Box, METH_O, NULL},
	 { "Fl_Box_swigregister", Fl_Box_swigregister, METH_O, NULL},
	 { "Fl_Box_swiginit", Fl_Box_swiginit, METH_VARARGS, NULL},
	 { "Fl_Button_draw", _wrap_Fl_Button_draw, METH_O, "Fl_Button_draw(Fl_Button self)"},
	 { "Fl_Button_handle", _wrap_Fl_Button_handle, METH_VARARGS, "Fl_Button_handle(Fl_Button self, int arg0) -> int"},
	 { "new_Fl_Button", _wrap_new_Fl_Button, METH_VARARGS, "new_Fl_Button(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Button"},
	 { "Fl_Button_value", _wrap_Fl_Button_value, METH_VARARGS, "\n"
		"Fl_Button_value(Fl_Button self, int v) -> int\n"
		"Fl_Button_value(Fl_Button self) -> char\n"
		""},
	 { "Fl_Button_set", _wrap_Fl_Button_set, METH_O, "Fl_Button_set(Fl_Button self) -> int"},
	 { "Fl_Button_clear", _wrap_Fl_Button_clear, METH_O, "Fl_Button_clear(Fl_Button self) -> int"},
	 { "Fl_Button_setonly", _wrap_Fl_Button_setonly, METH_O, "Fl_Button_setonly(Fl_Button self)"},
	 { "Fl_Button_down_box", _wrap_Fl_Button_down_box, METH_VARARGS, "\n"
		"Fl_Button_down_box(Fl_Button self) -> Fl_Boxtype\n"
		"Fl_Button_down_box(Fl_Button self, Fl_Boxtype b)\n"
		""},
	 { "Fl_Button_shortcut", _wrap_Fl_Button_shortcut, METH_VARARGS, "\n"
		"Fl_Button_shortcut(Fl_Button self) -> int\n"
		"Fl_Button_shortcut(Fl_Button self, int s)\n"
		"Fl_Button_shortcut(Fl_Button self, char const * s)\n"
		""},
	 { "Fl_Button_down_color", _wrap_Fl_Button_down_color, METH_VARARGS, "\n"
		"Fl_Button_down_color(Fl_Button self) -> Fl_Color\n"
		"Fl_Button_down_color(Fl_Button self, unsigned int c)\n"
		""},
	 { "Fl_Button_compact", _wrap_Fl_Button_compact, METH_VARARGS, "\n"
		"Fl_Button_compact(Fl_Button self, uchar v)\n"
		"Fl_Button_compact(Fl_Button self) -> uchar\n"
		""},
	 { "Fl_Button_init_type", _wrap_Fl_Button_init_type, METH_VARARGS, "Fl_Button_init_type(Fl_Button self, char * Fl_Button)"},
	 { "delete_Fl_Button", _wrap_delete_Fl_Button, METH_O, "delete_Fl_Button(Fl_Button self)"},
	 { "disown_Fl_Button", _wrap_disown_Fl_Button, METH_O, NULL},
	 { "Fl_Button_swigregister", Fl_Button_swigregister, METH_O, NULL},
	 { "Fl_Button_swiginit", Fl_Button_swiginit, METH_VARARGS, NULL},
	 { "Fl_Shortcut_Button_handle", _wrap_Fl_Shortcut_Button_handle, METH_VARARGS, "Fl_Shortcut_Button_handle(Fl_Shortcut_Button self, int arg0) -> int"},
	 { "Fl_Shortcut_Button_draw", _wrap_Fl_Shortcut_Button_draw, METH_O, "Fl_Shortcut_Button_draw(Fl_Shortcut_Button self)"},
	 { "new_Fl_Shortcut_Button", _wrap_new_Fl_Shortcut_Button, METH_VARARGS, "new_Fl_Shortcut_Button(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Shortcut_Button"},
	 { "Fl_Shortcut_Button_value", _wrap_Fl_Shortcut_Button_value, METH_VARARGS, "\n"
		"Fl_Shortcut_Button_value(Fl_Shortcut_Button self, Fl_Shortcut shortcut)\n"
		"Fl_Shortcut_Button_value(Fl_Shortcut_Button self) -> Fl_Shortcut\n"
		""},
	 { "Fl_Shortcut_Button_init_type", _wrap_Fl_Shortcut_Button_init_type, METH_VARARGS, "Fl_Shortcut_Button_init_type(Fl_Shortcut_Button self, char * Fl_Shortcut_Button)"},
	 { "delete_Fl_Shortcut_Button", _wrap_delete_Fl_Shortcut_Button, METH_O, "delete_Fl_Shortcut_Button(Fl_Shortcut_Button self)"},
	 { "disown_Fl_Shortcut_Button", _wrap_disown_Fl_Shortcut_Button, METH_O, NULL},
	 { "Fl_Shortcut_Button_swigregister", Fl_Shortcut_Button_swigregister, METH_O, NULL},
	 { "Fl_Shortcut_Button_swiginit", Fl_Shortcut_Button_swiginit, METH_VARARGS, NULL},
	 { "new_FL_CHART_ENTRY", _wrap_new_FL_CHART_ENTRY, METH_NOARGS, "new_FL_CHART_ENTRY() -> FL_CHART_ENTRY"},
	 { "delete_FL_CHART_ENTRY", _wrap_delete_FL_CHART_ENTRY, METH_O, "delete_FL_CHART_ENTRY(FL_CHART_ENTRY self)"},
	 { "FL_CHART_ENTRY_swigregister", FL_CHART_ENTRY_swigregister, METH_O, NULL},
	 { "FL_CHART_ENTRY_swiginit", FL_CHART_ENTRY_swiginit, METH_VARARGS, NULL},
	 { "Fl_Chart_draw", _wrap_Fl_Chart_draw, METH_O, "Fl_Chart_draw(Fl_Chart self)"},
	 { "new_Fl_Chart", _wrap_new_Fl_Chart, METH_VARARGS, "new_Fl_Chart(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Chart"},
	 { "delete_Fl_Chart", _wrap_delete_Fl_Chart, METH_O, "delete_Fl_Chart(Fl_Chart self)"},
	 { "Fl_Chart_clear", _wrap_Fl_Chart_clear, METH_O, "Fl_Chart_clear(Fl_Chart self)"},
	 { "Fl_Chart_add", _wrap_Fl_Chart_add, METH_VARARGS, "Fl_Chart_add(Fl_Chart self, double val, char const * str=None, unsigned int col=0)"},
	 { "Fl_Chart_insert", _wrap_Fl_Chart_insert, METH_VARARGS, "Fl_Chart_insert(Fl_Chart self, int ind, double val, char const * str=None, unsigned int col=0)"},
	 { "Fl_Chart_replace", _wrap_Fl_Chart_replace, METH_VARARGS, "Fl_Chart_replace(Fl_Chart self, int ind, double val, char const * str=None, unsigned int col=0)"},
	 { "Fl_Chart_bounds", _wrap_Fl_Chart_bounds, METH_VARARGS, "\n"
		"Fl_Chart_bounds(Fl_Chart self, double * a, double * b)\n"
		"Fl_Chart_bounds(Fl_Chart self, double a, double b)\n"
		""},
	 { "Fl_Chart_size", _wrap_Fl_Chart_size, METH_VARARGS, "\n"
		"Fl_Chart_size(Fl_Chart self) -> int\n"
		"Fl_Chart_size(Fl_Chart self, int W, int H)\n"
		""},
	 { "Fl_Chart_maxsize", _wrap_Fl_Chart_maxsize, METH_VARARGS, "\n"
		"Fl_Chart_maxsize(Fl_Chart self) -> int\n"
		"Fl_Chart_maxsize(Fl_Chart self, int m)\n"
		""},
	 { "Fl_Chart_textfont", _wrap_Fl_Chart_textfont, METH_VARARGS, "\n"
		"Fl_Chart_textfont(Fl_Chart self) -> Fl_Font\n"
		"Fl_Chart_textfont(Fl_Chart self, Fl_Font s)\n"
		""},
	 { "Fl_Chart_textsize", _wrap_Fl_Chart_textsize, METH_VARARGS, "\n"
		"Fl_Chart_textsize(Fl_Chart self) -> Fl_Fontsize\n"
		"Fl_Chart_textsize(Fl_Chart self, Fl_Fontsize s)\n"
		""},
	 { "Fl_Chart_textcolor", _wrap_Fl_Chart_textcolor, METH_VARARGS, "\n"
		"Fl_Chart_textcolor(Fl_Chart self) -> Fl_Color\n"
		"Fl_Chart_textcolor(Fl_Chart self, Fl_Color n)\n"
		""},
	 { "Fl_Chart_autosize", _wrap_Fl_Chart_autosize, METH_VARARGS, "\n"
		"Fl_Chart_autosize(Fl_Chart self) -> uchar\n"
		"Fl_Chart_autosize(Fl_Chart self, uchar n)\n"
		""},
	 { "Fl_Chart_init_type", _wrap_Fl_Chart_init_type, METH_VARARGS, "Fl_Chart_init_type(Fl_Chart self, char * Fl_Chart)"},
	 { "disown_Fl_Chart", _wrap_disown_Fl_Chart, METH_O, NULL},
	 { "Fl_Chart_swigregister", Fl_Chart_swigregister, METH_O, NULL},
	 { "Fl_Chart_swiginit", Fl_Chart_swiginit, METH_VARARGS, NULL},
	 { "Fl_Check_Browser_item_first", _wrap_Fl_Check_Browser_item_first, METH_O, "Fl_Check_Browser_item_first(Fl_Check_Browser self) -> void *"},
	 { "Fl_Check_Browser_item_next", _wrap_Fl_Check_Browser_item_next, METH_VARARGS, "Fl_Check_Browser_item_next(Fl_Check_Browser self, void * arg0) -> void *"},
	 { "Fl_Check_Browser_item_prev", _wrap_Fl_Check_Browser_item_prev, METH_VARARGS, "Fl_Check_Browser_item_prev(Fl_Check_Browser self, void * arg0) -> void *"},
	 { "Fl_Check_Browser_item_height", _wrap_Fl_Check_Browser_item_height, METH_VARARGS, "Fl_Check_Browser_item_height(Fl_Check_Browser self, void * arg0) -> int"},
	 { "Fl_Check_Browser_item_width", _wrap_Fl_Check_Browser_item_width, METH_VARARGS, "Fl_Check_Browser_item_width(Fl_Check_Browser self, void * arg0) -> int"},
	 { "Fl_Check_Browser_item_draw", _wrap_Fl_Check_Browser_item_draw, METH_VARARGS, "Fl_Check_Browser_item_draw(Fl_Check_Browser self, void * arg0, int arg1, int arg2, int arg3, int arg4)"},
	 { "Fl_Check_Browser_item_select", _wrap_Fl_Check_Browser_item_select, METH_VARARGS, "Fl_Check_Browser_item_select(Fl_Check_Browser self, void * arg0, int arg1)"},
	 { "Fl_Check_Browser_item_selected", _wrap_Fl_Check_Browser_item_selected, METH_VARARGS, "Fl_Check_Browser_item_selected(Fl_Check_Browser self, void * arg0) -> int"},
	 { "Fl_Check_Browser_item_text", _wrap_Fl_Check_Browser_item_text, METH_VARARGS, "Fl_Check_Browser_item_text(Fl_Check_Browser self, void * item) -> char const *"},
	 { "Fl_Check_Browser_item_at", _wrap_Fl_Check_Browser_item_at, METH_VARARGS, "Fl_Check_Browser_item_at(Fl_Check_Browser self, int index) -> void *"},
	 { "Fl_Check_Browser_item_swap", _wrap_Fl_Check_Browser_item_swap, METH_VARARGS, "\n"
		"Fl_Check_Browser_item_swap(Fl_Check_Browser self, int ia, int ib)\n"
		"Fl_Check_Browser_item_swap(Fl_Check_Browser self, void * a, void * b)\n"
		""},
	 { "new_Fl_Check_Browser", _wrap_new_Fl_Check_Browser, METH_VARARGS, "new_Fl_Check_Browser(PyObject * _self, int x, int y, int w, int h, char const * l=None) -> Fl_Check_Browser"},
	 { "delete_Fl_Check_Browser", _wrap_delete_Fl_Check_Browser, METH_O, "delete_Fl_Check_Browser(Fl_Check_Browser self)"},
	 { "Fl_Check_Browser_remove", _wrap_Fl_Check_Browser_remove, METH_VARARGS, "Fl_Check_Browser_remove(Fl_Check_Browser self, int item) -> int"},
	 { "Fl_Check_Browser_add", _wrap_Fl_Check_Browser_add, METH_VARARGS, "\n"
		"Fl_Check_Browser_add(Fl_Check_Browser self, char const * s) -> int\n"
		"Fl_Check_Browser_add(Fl_Check_Browser self, char const * s, int b) -> int\n"
		""},
	 { "Fl_Check_Browser_clear", _wrap_Fl_Check_Browser_clear, METH_O, "Fl_Check_Browser_clear(Fl_Check_Browser self)"},
	 { "Fl_Check_Browser_nitems", _wrap_Fl_Check_Browser_nitems, METH_O, "Fl_Check_Browser_nitems(Fl_Check_Browser self) -> int"},
	 { "Fl_Check_Browser_nchecked", _wrap_Fl_Check_Browser_nchecked, METH_O, "Fl_Check_Browser_nchecked(Fl_Check_Browser self) -> int"},
	 { "Fl_Check_Browser_checked", _wrap_Fl_Check_Browser_checked, METH_VARARGS, "\n"
		"Fl_Check_Browser_checked(Fl_Check_Browser self, int item) -> int\n"
		"Fl_Check_Browser_checked(Fl_Check_Browser self, int item, int b)\n"
		""},
	 { "Fl_Check_Browser_set_checked", _wrap_Fl_Check_Browser_set_checked, METH_VARARGS, "Fl_Check_Browser_set_checked(Fl_Check_Browser self, int item)"},
	 { "Fl_Check_Browser_check_all", _wrap_Fl_Check_Browser_check_all, METH_O, "Fl_Check_Browser_check_all(Fl_Check_Browser self)"},
	 { "Fl_Check_Browser_check_none", _wrap_Fl_Check_Browser_check_none, METH_O, "Fl_Check_Browser_check_none(Fl_Check_Browser self)"},
	 { "Fl_Check_Browser_value", _wrap_Fl_Check_Browser_value, METH_O, "Fl_Check_Browser_value(Fl_Check_Browser self) -> int"},
	 { "Fl_Check_Browser_text", _wrap_Fl_Check_Browser_text, METH_VARARGS, "Fl_Check_Browser_text(Fl_Check_Browser self, int item) -> char *"},
	 { "Fl_Check_Browser_handle", _wrap_Fl_Check_Browser_handle, METH_VARARGS, "Fl_Check_Browser_handle(Fl_Check_Browser self, int arg0) -> int"},
	 { "Fl_Check_Browser_init_type", _wrap_Fl_Check_Browser_init_type, METH_VARARGS, "Fl_Check_Browser_init_type(Fl_Check_Browser self, char * Fl_Check_Browser)"},
	 { "disown_Fl_Check_Browser", _wrap_disown_Fl_Check_Browser, METH_O, NULL},
	 { "Fl_Check_Browser_draw", _wrap_Fl_Check_Browser_draw, METH_O, "Fl_Check_Browser_draw(Fl_Check_Browser self)"},
	 { "Fl_Check_Browser_item_last", _wrap_Fl_Check_Browser_item_last, METH_O, "Fl_Check_Browser_item_last(Fl_Check_Browser self) -> void *"},
	 { "Fl_Check_Browser_item_quick_height", _wrap_Fl_Check_Browser_item_quick_height, METH_VARARGS, "Fl_Check_Browser_item_quick_height(Fl_Check_Browser self, void * item) -> int"},
	 { "Fl_Check_Browser_full_width", _wrap_Fl_Check_Browser_full_width, METH_O, "Fl_Check_Browser_full_width(Fl_Check_Browser self) -> int"},
	 { "Fl_Check_Browser_full_height", _wrap_Fl_Check_Browser_full_height, METH_O, "Fl_Check_Browser_full_height(Fl_Check_Browser self) -> int"},
	 { "Fl_Check_Browser_incr_height", _wrap_Fl_Check_Browser_incr_height, METH_O, "Fl_Check_Browser_incr_height(Fl_Check_Browser self) -> int"},
	 { "Fl_Check_Browser_swigregister", Fl_Check_Browser_swigregister, METH_O, NULL},
	 { "Fl_Check_Browser_swiginit", Fl_Check_Browser_swiginit, METH_VARARGS, NULL},
	 { "Fl_Light_Button_draw", _wrap_Fl_Light_Button_draw, METH_O, "Fl_Light_Button_draw(Fl_Light_Button self)"},
	 { "Fl_Light_Button_handle", _wrap_Fl_Light_Button_handle, METH_VARARGS, "Fl_Light_Button_handle(Fl_Light_Button self, int arg0) -> int"},
	 { "new_Fl_Light_Button", _wrap_new_Fl_Light_Button, METH_VARARGS, "new_Fl_Light_Button(PyObject * _self, int x, int y, int w, int h, char const * l=None) -> Fl_Light_Button"},
	 { "Fl_Light_Button_init_type", _wrap_Fl_Light_Button_init_type, METH_VARARGS, "Fl_Light_Button_init_type(Fl_Light_Button self, char * Fl_Light_Button)"},
	 { "delete_Fl_Light_Button", _wrap_delete_Fl_Light_Button, METH_O, "delete_Fl_Light_Button(Fl_Light_Button self)"},
	 { "disown_Fl_Light_Button", _wrap_disown_Fl_Light_Button, METH_O, NULL},
	 { "Fl_Light_Button_swigregister", Fl_Light_Button_swigregister, METH_O, NULL},
	 { "Fl_Light_Button_swiginit", Fl_Light_Button_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Check_Button", _wrap_new_Fl_Check_Button, METH_VARARGS, "new_Fl_Check_Button(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Check_Button"},
	 { "Fl_Check_Button_init_type", _wrap_Fl_Check_Button_init_type, METH_VARARGS, "Fl_Check_Button_init_type(Fl_Check_Button self, char * Fl_Check_Button)"},
	 { "delete_Fl_Check_Button", _wrap_delete_Fl_Check_Button, METH_O, "delete_Fl_Check_Button(Fl_Check_Button self)"},
	 { "disown_Fl_Check_Button", _wrap_disown_Fl_Check_Button, METH_O, NULL},
	 { "Fl_Check_Button_draw", _wrap_Fl_Check_Button_draw, METH_O, "Fl_Check_Button_draw(Fl_Check_Button self)"},
	 { "Fl_Check_Button_swigregister", Fl_Check_Button_swigregister, METH_O, NULL},
	 { "Fl_Check_Button_swiginit", Fl_Check_Button_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Menu_", _wrap_new_Fl_Menu_, METH_VARARGS, "new_Fl_Menu_(PyObject * _self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Menu_"},
	 { "delete_Fl_Menu_", _wrap_delete_Fl_Menu_, METH_O, "delete_Fl_Menu_(Fl_Menu_ self)"},
	 { "Fl_Menu__item_pathname", _wrap_Fl_Menu__item_pathname, METH_VARARGS, "Fl_Menu__item_pathname(Fl_Menu_ self, char * name, int namelen, Fl_Menu_Item finditem=None) -> int"},
	 { "Fl_Menu__picked", _wrap_Fl_Menu__picked, METH_VARARGS, "Fl_Menu__picked(Fl_Menu_ self, Fl_Menu_Item arg2) -> Fl_Menu_Item"},
	 { "Fl_Menu__find_item", _wrap_Fl_Menu__find_item, METH_VARARGS, "\n"
		"Fl_Menu__find_item(Fl_Menu_ self, char const * name) -> Fl_Menu_Item\n"
		"Fl_Menu__find_item(Fl_Menu_ self, Fl_Callback * arg2) -> Fl_Menu_Item\n"
		""},
	 { "Fl_Menu__find_item_with_user_data", _wrap_Fl_Menu__find_item_with_user_data, METH_VARARGS, "Fl_Menu__find_item_with_user_data(Fl_Menu_ self, void * arg2) -> Fl_Menu_Item"},
	 { "Fl_Menu__find_item_with_argument", _wrap_Fl_Menu__find_item_with_argument, METH_VARARGS, "Fl_Menu__find_item_with_argument(Fl_Menu_ self, long arg2) -> Fl_Menu_Item"},
	 { "Fl_Menu__find_index", _wrap_Fl_Menu__find_index, METH_VARARGS, "\n"
		"Fl_Menu__find_index(Fl_Menu_ self, char const * name) -> int\n"
		"Fl_Menu__find_index(Fl_Menu_ self, Fl_Menu_Item item) -> int\n"
		"Fl_Menu__find_index(Fl_Menu_ self, Fl_Callback * cb) -> int\n"
		""},
	 { "Fl_Menu__test_shortcut", _wrap_Fl_Menu__test_shortcut, METH_O, "Fl_Menu__test_shortcut(Fl_Menu_ self) -> Fl_Menu_Item"},
	 { "Fl_Menu__menu_end", _wrap_Fl_Menu__menu_end, METH_O, "Fl_Menu__menu_end(Fl_Menu_ self) -> Fl_Menu_Item"},
	 { "Fl_Menu__insert", _wrap_Fl_Menu__insert, METH_VARARGS, "\n"
		"Fl_Menu__insert(Fl_Menu_ self, int index, char const * arg3, int shortcut, Fl_Callback * arg5, void * arg6=None, int arg7=0) -> int\n"
		"Fl_Menu__insert(Fl_Menu_ self, int index, char const * a, char const * b, Fl_Callback * c, void * d=None, int e=0) -> int\n"
		""},
	 { "Fl_Menu__size", _wrap_Fl_Menu__size, METH_VARARGS, "\n"
		"Fl_Menu__size(Fl_Menu_ self) -> int\n"
		"Fl_Menu__size(Fl_Menu_ self, int W, int H)\n"
		""},
	 { "Fl_Menu__clear", _wrap_Fl_Menu__clear, METH_O, "Fl_Menu__clear(Fl_Menu_ self)"},
	 { "Fl_Menu__clear_submenu", _wrap_Fl_Menu__clear_submenu, METH_VARARGS, "Fl_Menu__clear_submenu(Fl_Menu_ self, int index) -> int"},
	 { "Fl_Menu__replace", _wrap_Fl_Menu__replace, METH_VARARGS, "Fl_Menu__replace(Fl_Menu_ self, int arg2, char const * arg3)"},
	 { "Fl_Menu__remove", _wrap_Fl_Menu__remove, METH_VARARGS, "Fl_Menu__remove(Fl_Menu_ self, int arg2)"},
	 { "Fl_Menu__shortcut", _wrap_Fl_Menu__shortcut, METH_VARARGS, "Fl_Menu__shortcut(Fl_Menu_ self, int i, int s)"},
	 { "Fl_Menu__mode", _wrap_Fl_Menu__mode, METH_VARARGS, "\n"
		"Fl_Menu__mode(Fl_Menu_ self, int i, int fl)\n"
		"Fl_Menu__mode(Fl_Menu_ self, int i) -> int\n"
		""},
	 { "Fl_Menu__mvalue", _wrap_Fl_Menu__mvalue, METH_O, "Fl_Menu__mvalue(Fl_Menu_ self) -> Fl_Menu_Item"},
	 { "Fl_Menu__prev_mvalue", _wrap_Fl_Menu__prev_mvalue, METH_O, "Fl_Menu__prev_mvalue(Fl_Menu_ self) -> Fl_Menu_Item"},
	 { "Fl_Menu__value", _wrap_Fl_Menu__value, METH_VARARGS, "\n"
		"Fl_Menu__value(Fl_Menu_ self) -> int\n"
		"Fl_Menu__value(Fl_Menu_ self, int i) -> int\n"
		""},
	 { "Fl_Menu__text", _wrap_Fl_Menu__text, METH_VARARGS, "\n"
		"Fl_Menu__text(Fl_Menu_ self) -> char const\n"
		"Fl_Menu__text(Fl_Menu_ self, int i) -> char const *\n"
		""},
	 { "Fl_Menu__textfont", _wrap_Fl_Menu__textfont, METH_VARARGS, "\n"
		"Fl_Menu__textfont(Fl_Menu_ self) -> Fl_Font\n"
		"Fl_Menu__textfont(Fl_Menu_ self, Fl_Font c)\n"
		""},
	 { "Fl_Menu__textsize", _wrap_Fl_Menu__textsize, METH_VARARGS, "\n"
		"Fl_Menu__textsize(Fl_Menu_ self) -> Fl_Fontsize\n"
		"Fl_Menu__textsize(Fl_Menu_ self, Fl_Fontsize c)\n"
		""},
	 { "Fl_Menu__textcolor", _wrap_Fl_Menu__textcolor, METH_VARARGS, "\n"
		"Fl_Menu__textcolor(Fl_Menu_ self) -> Fl_Color\n"
		"Fl_Menu__textcolor(Fl_Menu_ self, Fl_Color c)\n"
		""},
	 { "Fl_Menu__down_box", _wrap_Fl_Menu__down_box, METH_VARARGS, "\n"
		"Fl_Menu__down_box(Fl_Menu_ self) -> Fl_Boxtype\n"
		"Fl_Menu__down_box(Fl_Menu_ self, Fl_Boxtype b)\n"
		""},
	 { "Fl_Menu__menu_box", _wrap_Fl_Menu__menu_box, METH_VARARGS, "\n"
		"Fl_Menu__menu_box(Fl_Menu_ self) -> Fl_Boxtype\n"
		"Fl_Menu__menu_box(Fl_Menu_ self, Fl_Boxtype b)\n"
		""},
	 { "Fl_Menu__down_color", _wrap_Fl_Menu__down_color, METH_VARARGS, "\n"
		"Fl_Menu__down_color(Fl_Menu_ self) -> Fl_Color\n"
		"Fl_Menu__down_color(Fl_Menu_ self, unsigned int c)\n"
		""},
	 { "Fl_Menu__setonly", _wrap_Fl_Menu__setonly, METH_VARARGS, "Fl_Menu__setonly(Fl_Menu_ self, Fl_Menu_Item item)"},
	 { "Fl_Menu__init_type", _wrap_Fl_Menu__init_type, METH_VARARGS, "Fl_Menu__init_type(Fl_Menu_ self, char * Fl_Menu_)"},
	 { "Fl_Menu__copy", _wrap_Fl_Menu__copy, METH_VARARGS, "\n"
		"Fl_Menu__copy(Fl_Menu_ self, Fl_Menu_Item m, void * user_data=None)\n"
		"Fl_Menu__copy(Fl_Menu_ self, PyObject * args, PyObject * user_data=None)\n"
		""},
	 { "Fl_Menu__add", _wrap_Fl_Menu__add, METH_VARARGS, "\n"
		"Fl_Menu__add(Fl_Menu_ self, char const * arg2, int shortcut, Fl_Callback * arg4, void * arg5=None, int arg6=0) -> int\n"
		"Fl_Menu__add(Fl_Menu_ self, char const * arg2) -> int\n"
		"Fl_Menu__add(Fl_Menu_ self, PyObject * lObj, PyObject * sObj, PyObject * cObj, PyObject * uObj=None, PyObject * fObj=None) -> int\n"
		""},
	 { "Fl_Menu__menu", _wrap_Fl_Menu__menu, METH_VARARGS, "\n"
		"Fl_Menu__menu(Fl_Menu_ self) -> Fl_Menu_Item\n"
		"Fl_Menu__menu(Fl_Menu_ self, PyObject * args)\n"
		"Fl_Menu__menu(Fl_Menu_ self) -> PyObject *\n"
		""},
	 { "disown_Fl_Menu_", _wrap_disown_Fl_Menu_, METH_O, NULL},
	 { "Fl_Menu__swigregister", Fl_Menu__swigregister, METH_O, NULL},
	 { "Fl_Menu__swiginit", Fl_Menu__swiginit, METH_VARARGS, NULL},
	 { "Fl_Choice_draw", _wrap_Fl_Choice_draw, METH_O, "Fl_Choice_draw(Fl_Choice self)"},
	 { "Fl_Choice_handle", _wrap_Fl_Choice_handle, METH_VARARGS, "Fl_Choice_handle(Fl_Choice self, int arg0) -> int"},
	 { "new_Fl_Choice", _wrap_new_Fl_Choice, METH_VARARGS, "new_Fl_Choice(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Choice"},
	 { "Fl_Choice_value", _wrap_Fl_Choice_value, METH_VARARGS, "\n"
		"Fl_Choice_value(Fl_Choice self) -> int\n"
		"Fl_Choice_value(Fl_Choice self, int v) -> int\n"
		""},
	 { "Fl_Choice_init_type", _wrap_Fl_Choice_init_type, METH_VARARGS, "Fl_Choice_init_type(Fl_Choice self, char * Fl_Choice)"},
	 { "delete_Fl_Choice", _wrap_delete_Fl_Choice, METH_O, "delete_Fl_Choice(Fl_Choice self)"},
	 { "disown_Fl_Choice", _wrap_disown_Fl_Choice, METH_O, NULL},
	 { "Fl_Choice_swigregister", Fl_Choice_swigregister, METH_O, NULL},
	 { "Fl_Choice_swiginit", Fl_Choice_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Copy_Surface", _wrap_new_Fl_Copy_Surface, METH_VARARGS, "new_Fl_Copy_Surface(int w, int h) -> Fl_Copy_Surface"},
	 { "delete_Fl_Copy_Surface", _wrap_delete_Fl_Copy_Surface, METH_O, "delete_Fl_Copy_Surface(Fl_Copy_Surface self)"},
	 { "Fl_Copy_Surface_set_current", _wrap_Fl_Copy_Surface_set_current, METH_O, "Fl_Copy_Surface_set_current(Fl_Copy_Surface self)"},
	 { "Fl_Copy_Surface_is_current", _wrap_Fl_Copy_Surface_is_current, METH_O, "Fl_Copy_Surface_is_current(Fl_Copy_Surface self) -> bool"},
	 { "Fl_Copy_Surface_w", _wrap_Fl_Copy_Surface_w, METH_O, "Fl_Copy_Surface_w(Fl_Copy_Surface self) -> int"},
	 { "Fl_Copy_Surface_h", _wrap_Fl_Copy_Surface_h, METH_O, "Fl_Copy_Surface_h(Fl_Copy_Surface self) -> int"},
	 { "Fl_Copy_Surface_origin", _wrap_Fl_Copy_Surface_origin, METH_VARARGS, "\n"
		"Fl_Copy_Surface_origin(Fl_Copy_Surface self, int * x, int * y)\n"
		"Fl_Copy_Surface_origin(Fl_Copy_Surface self, int x, int y)\n"
		""},
	 { "Fl_Copy_Surface_printable_rect", _wrap_Fl_Copy_Surface_printable_rect, METH_VARARGS, "Fl_Copy_Surface_printable_rect(Fl_Copy_Surface self, int * w, int * h) -> int"},
	 { "Fl_Copy_Surface_swigregister", Fl_Copy_Surface_swigregister, METH_O, NULL},
	 { "Fl_Copy_Surface_swiginit", Fl_Copy_Surface_swiginit, METH_VARARGS, NULL},
	 { "Fl_Copy_Surface_Driver_swigregister", Fl_Copy_Surface_Driver_swigregister, METH_O, NULL},
	 { "Fl_Clock_Output_draw", _wrap_Fl_Clock_Output_draw, METH_O, "Fl_Clock_Output_draw(Fl_Clock_Output self)"},
	 { "new_Fl_Clock_Output", _wrap_new_Fl_Clock_Output, METH_VARARGS, "new_Fl_Clock_Output(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Clock_Output"},
	 { "Fl_Clock_Output_value", _wrap_Fl_Clock_Output_value, METH_VARARGS, "\n"
		"Fl_Clock_Output_value(Fl_Clock_Output self, ulong v)\n"
		"Fl_Clock_Output_value(Fl_Clock_Output self, int H, int m, int s)\n"
		"Fl_Clock_Output_value(Fl_Clock_Output self) -> ulong\n"
		""},
	 { "Fl_Clock_Output_hour", _wrap_Fl_Clock_Output_hour, METH_O, "Fl_Clock_Output_hour(Fl_Clock_Output self) -> int"},
	 { "Fl_Clock_Output_minute", _wrap_Fl_Clock_Output_minute, METH_O, "Fl_Clock_Output_minute(Fl_Clock_Output self) -> int"},
	 { "Fl_Clock_Output_second", _wrap_Fl_Clock_Output_second, METH_O, "Fl_Clock_Output_second(Fl_Clock_Output self) -> int"},
	 { "Fl_Clock_Output_shadow", _wrap_Fl_Clock_Output_shadow, METH_VARARGS, "\n"
		"Fl_Clock_Output_shadow(Fl_Clock_Output self) -> int\n"
		"Fl_Clock_Output_shadow(Fl_Clock_Output self, int mode)\n"
		""},
	 { "Fl_Clock_Output_init_type", _wrap_Fl_Clock_Output_init_type, METH_VARARGS, "Fl_Clock_Output_init_type(Fl_Clock_Output self, char * Fl_Clock_Output)"},
	 { "delete_Fl_Clock_Output", _wrap_delete_Fl_Clock_Output, METH_O, "delete_Fl_Clock_Output(Fl_Clock_Output self)"},
	 { "disown_Fl_Clock_Output", _wrap_disown_Fl_Clock_Output, METH_O, NULL},
	 { "Fl_Clock_Output_swigregister", Fl_Clock_Output_swigregister, METH_O, NULL},
	 { "Fl_Clock_Output_swiginit", Fl_Clock_Output_swiginit, METH_VARARGS, NULL},
	 { "Fl_Clock_handle", _wrap_Fl_Clock_handle, METH_VARARGS, "Fl_Clock_handle(Fl_Clock self, int arg0) -> int"},
	 { "new_Fl_Clock", _wrap_new_Fl_Clock, METH_VARARGS, "\n"
		"Fl_Clock(int X, int Y, int W, int H, char const * L=None)\n"
		"new_Fl_Clock(PyObject * _self, uchar t, int X, int Y, int W, int H, char const * L) -> Fl_Clock\n"
		""},
	 { "delete_Fl_Clock", _wrap_delete_Fl_Clock, METH_O, "delete_Fl_Clock(Fl_Clock self)"},
	 { "Fl_Clock_init_type", _wrap_Fl_Clock_init_type, METH_VARARGS, "Fl_Clock_init_type(Fl_Clock self, char * Fl_Clock)"},
	 { "disown_Fl_Clock", _wrap_disown_Fl_Clock, METH_O, NULL},
	 { "Fl_Clock_draw", _wrap_Fl_Clock_draw, METH_O, "Fl_Clock_draw(Fl_Clock self)"},
	 { "Fl_Clock_swigregister", Fl_Clock_swigregister, METH_O, NULL},
	 { "Fl_Clock_swiginit", Fl_Clock_swiginit, METH_VARARGS, NULL},
	 { "Fl_Value_Input_handle", _wrap_Fl_Value_Input_handle, METH_VARARGS, "Fl_Value_Input_handle(Fl_Value_Input self, int arg0) -> int"},
	 { "Fl_Value_Input_draw", _wrap_Fl_Value_Input_draw, METH_O, "Fl_Value_Input_draw(Fl_Value_Input self)"},
	 { "Fl_Value_Input_resize", _wrap_Fl_Value_Input_resize, METH_VARARGS, "Fl_Value_Input_resize(Fl_Value_Input self, int arg0, int arg1, int arg2, int arg3)"},
	 { "new_Fl_Value_Input", _wrap_new_Fl_Value_Input, METH_VARARGS, "new_Fl_Value_Input(PyObject * _self, int x, int y, int w, int h, char const * l=None) -> Fl_Value_Input"},
	 { "delete_Fl_Value_Input", _wrap_delete_Fl_Value_Input, METH_O, "delete_Fl_Value_Input(Fl_Value_Input self)"},
	 { "Fl_Value_Input_soft", _wrap_Fl_Value_Input_soft, METH_VARARGS, "\n"
		"Fl_Value_Input_soft(Fl_Value_Input self, char s)\n"
		"Fl_Value_Input_soft(Fl_Value_Input self) -> char\n"
		""},
	 { "Fl_Value_Input_shortcut", _wrap_Fl_Value_Input_shortcut, METH_VARARGS, "\n"
		"Fl_Value_Input_shortcut(Fl_Value_Input self) -> int\n"
		"Fl_Value_Input_shortcut(Fl_Value_Input self, int s)\n"
		""},
	 { "Fl_Value_Input_textfont", _wrap_Fl_Value_Input_textfont, METH_VARARGS, "\n"
		"Fl_Value_Input_textfont(Fl_Value_Input self) -> Fl_Font\n"
		"Fl_Value_Input_textfont(Fl_Value_Input self, Fl_Font s)\n"
		""},
	 { "Fl_Value_Input_textsize", _wrap_Fl_Value_Input_textsize, METH_VARARGS, "\n"
		"Fl_Value_Input_textsize(Fl_Value_Input self) -> Fl_Fontsize\n"
		"Fl_Value_Input_textsize(Fl_Value_Input self, Fl_Fontsize s)\n"
		""},
	 { "Fl_Value_Input_textcolor", _wrap_Fl_Value_Input_textcolor, METH_VARARGS, "\n"
		"Fl_Value_Input_textcolor(Fl_Value_Input self) -> Fl_Color\n"
		"Fl_Value_Input_textcolor(Fl_Value_Input self, Fl_Color n)\n"
		""},
	 { "Fl_Value_Input_cursor_color", _wrap_Fl_Value_Input_cursor_color, METH_VARARGS, "\n"
		"Fl_Value_Input_cursor_color(Fl_Value_Input self) -> Fl_Color\n"
		"Fl_Value_Input_cursor_color(Fl_Value_Input self, Fl_Color n)\n"
		""},
	 { "Fl_Value_Input_init_type", _wrap_Fl_Value_Input_init_type, METH_VARARGS, "Fl_Value_Input_init_type(Fl_Value_Input self, char * Fl_Value_Input)"},
	 { "disown_Fl_Value_Input", _wrap_disown_Fl_Value_Input, METH_O, NULL},
	 { "Fl_Value_Input_swigregister", Fl_Value_Input_swigregister, METH_O, NULL},
	 { "Fl_Value_Input_swiginit", Fl_Value_Input_swiginit, METH_VARARGS, NULL},
	 { "Flcc_HueBox_draw", _wrap_Flcc_HueBox_draw, METH_O, "Flcc_HueBox_draw(Flcc_HueBox self)"},
	 { "Flcc_HueBox_handle", _wrap_Flcc_HueBox_handle, METH_VARARGS, "Flcc_HueBox_handle(Flcc_HueBox self, int arg0) -> int"},
	 { "new_Flcc_HueBox", _wrap_new_Flcc_HueBox, METH_VARARGS, "new_Flcc_HueBox(PyObject * _self, int X, int Y, int W, int H) -> Flcc_HueBox"},
	 { "Flcc_HueBox_init_type", _wrap_Flcc_HueBox_init_type, METH_VARARGS, "Flcc_HueBox_init_type(Flcc_HueBox self, char * Flcc_HueBox)"},
	 { "delete_Flcc_HueBox", _wrap_delete_Flcc_HueBox, METH_O, "delete_Flcc_HueBox(Flcc_HueBox self)"},
	 { "disown_Flcc_HueBox", _wrap_disown_Flcc_HueBox, METH_O, NULL},
	 { "Flcc_HueBox_swigregister", Flcc_HueBox_swigregister, METH_O, NULL},
	 { "Flcc_HueBox_swiginit", Flcc_HueBox_swiginit, METH_VARARGS, NULL},
	 { "Flcc_ValueBox_draw", _wrap_Flcc_ValueBox_draw, METH_O, "Flcc_ValueBox_draw(Flcc_ValueBox self)"},
	 { "Flcc_ValueBox_handle", _wrap_Flcc_ValueBox_handle, METH_VARARGS, "Flcc_ValueBox_handle(Flcc_ValueBox self, int arg0) -> int"},
	 { "new_Flcc_ValueBox", _wrap_new_Flcc_ValueBox, METH_VARARGS, "new_Flcc_ValueBox(PyObject * _self, int X, int Y, int W, int H) -> Flcc_ValueBox"},
	 { "Flcc_ValueBox_init_type", _wrap_Flcc_ValueBox_init_type, METH_VARARGS, "Flcc_ValueBox_init_type(Flcc_ValueBox self, char * Flcc_ValueBox)"},
	 { "delete_Flcc_ValueBox", _wrap_delete_Flcc_ValueBox, METH_O, "delete_Flcc_ValueBox(Flcc_ValueBox self)"},
	 { "disown_Flcc_ValueBox", _wrap_disown_Flcc_ValueBox, METH_O, NULL},
	 { "Flcc_ValueBox_swigregister", Flcc_ValueBox_swigregister, METH_O, NULL},
	 { "Flcc_ValueBox_swiginit", Flcc_ValueBox_swiginit, METH_VARARGS, NULL},
	 { "Flcc_Value_Input_format", _wrap_Flcc_Value_Input_format, METH_VARARGS, "Flcc_Value_Input_format(Flcc_Value_Input self, char * arg0) -> int"},
	 { "new_Flcc_Value_Input", _wrap_new_Flcc_Value_Input, METH_VARARGS, "new_Flcc_Value_Input(PyObject * _self, int X, int Y, int W, int H) -> Flcc_Value_Input"},
	 { "Flcc_Value_Input_init_type", _wrap_Flcc_Value_Input_init_type, METH_VARARGS, "Flcc_Value_Input_init_type(Flcc_Value_Input self, char * Flcc_Value_Input)"},
	 { "delete_Flcc_Value_Input", _wrap_delete_Flcc_Value_Input, METH_O, "delete_Flcc_Value_Input(Flcc_Value_Input self)"},
	 { "disown_Flcc_Value_Input", _wrap_disown_Flcc_Value_Input, METH_O, NULL},
	 { "Flcc_Value_Input_draw", _wrap_Flcc_Value_Input_draw, METH_O, "Flcc_Value_Input_draw(Flcc_Value_Input self)"},
	 { "Flcc_Value_Input_swigregister", Flcc_Value_Input_swigregister, METH_O, NULL},
	 { "Flcc_Value_Input_swiginit", Flcc_Value_Input_swiginit, METH_VARARGS, NULL},
	 { "Fl_Color_Chooser_handle", _wrap_Fl_Color_Chooser_handle, METH_VARARGS, "Fl_Color_Chooser_handle(Fl_Color_Chooser self, int e) -> int"},
	 { "Fl_Color_Chooser_mode", _wrap_Fl_Color_Chooser_mode, METH_VARARGS, "\n"
		"Fl_Color_Chooser_mode(Fl_Color_Chooser self) -> int\n"
		"Fl_Color_Chooser_mode(Fl_Color_Chooser self, int newMode)\n"
		""},
	 { "Fl_Color_Chooser_hue", _wrap_Fl_Color_Chooser_hue, METH_O, "Fl_Color_Chooser_hue(Fl_Color_Chooser self) -> double"},
	 { "Fl_Color_Chooser_saturation", _wrap_Fl_Color_Chooser_saturation, METH_O, "Fl_Color_Chooser_saturation(Fl_Color_Chooser self) -> double"},
	 { "Fl_Color_Chooser_value", _wrap_Fl_Color_Chooser_value, METH_O, "Fl_Color_Chooser_value(Fl_Color_Chooser self) -> double"},
	 { "Fl_Color_Chooser_r", _wrap_Fl_Color_Chooser_r, METH_O, "Fl_Color_Chooser_r(Fl_Color_Chooser self) -> double"},
	 { "Fl_Color_Chooser_g", _wrap_Fl_Color_Chooser_g, METH_O, "Fl_Color_Chooser_g(Fl_Color_Chooser self) -> double"},
	 { "Fl_Color_Chooser_b", _wrap_Fl_Color_Chooser_b, METH_O, "Fl_Color_Chooser_b(Fl_Color_Chooser self) -> double"},
	 { "Fl_Color_Chooser_hsv", _wrap_Fl_Color_Chooser_hsv, METH_VARARGS, "Fl_Color_Chooser_hsv(Fl_Color_Chooser self, double H, double S, double V) -> int"},
	 { "Fl_Color_Chooser_rgb", _wrap_Fl_Color_Chooser_rgb, METH_VARARGS, "Fl_Color_Chooser_rgb(Fl_Color_Chooser self, double R, double G, double B) -> int"},
	 { "Fl_Color_Chooser_hsv2rgb", _wrap_Fl_Color_Chooser_hsv2rgb, METH_VARARGS, "Fl_Color_Chooser_hsv2rgb(double H, double S, double V, double & R, double & G, double & B)"},
	 { "Fl_Color_Chooser_rgb2hsv", _wrap_Fl_Color_Chooser_rgb2hsv, METH_VARARGS, "Fl_Color_Chooser_rgb2hsv(double R, double G, double B, double & H, double & S, double & V)"},
	 { "new_Fl_Color_Chooser", _wrap_new_Fl_Color_Chooser, METH_VARARGS, "new_Fl_Color_Chooser(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Color_Chooser"},
	 { "Fl_Color_Chooser_init_type", _wrap_Fl_Color_Chooser_init_type, METH_VARARGS, "Fl_Color_Chooser_init_type(Fl_Color_Chooser self, char * Fl_Color_Chooser)"},
	 { "delete_Fl_Color_Chooser", _wrap_delete_Fl_Color_Chooser, METH_O, "delete_Fl_Color_Chooser(Fl_Color_Chooser self)"},
	 { "disown_Fl_Color_Chooser", _wrap_disown_Fl_Color_Chooser, METH_O, NULL},
	 { "Fl_Color_Chooser_draw", _wrap_Fl_Color_Chooser_draw, METH_O, "Fl_Color_Chooser_draw(Fl_Color_Chooser self)"},
	 { "Fl_Color_Chooser_swigregister", Fl_Color_Chooser_swigregister, METH_O, NULL},
	 { "Fl_Color_Chooser_swiginit", Fl_Color_Chooser_swiginit, METH_VARARGS, NULL},
	 { "fl_color_chooser", _wrap_fl_color_chooser, METH_VARARGS, "\n"
		"fl_color_chooser(char const * name, double & r, double & g, double & b, int m=-1) -> int\n"
		"fl_color_chooser(char const * name, uchar & r, uchar & g, uchar & b, int m=-1) -> int\n"
		""},
	 { "Fl_Counter_draw", _wrap_Fl_Counter_draw, METH_O, "Fl_Counter_draw(Fl_Counter self)"},
	 { "Fl_Counter_handle", _wrap_Fl_Counter_handle, METH_VARARGS, "Fl_Counter_handle(Fl_Counter self, int arg0) -> int"},
	 { "new_Fl_Counter", _wrap_new_Fl_Counter, METH_VARARGS, "new_Fl_Counter(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Counter"},
	 { "delete_Fl_Counter", _wrap_delete_Fl_Counter, METH_O, "delete_Fl_Counter(Fl_Counter self)"},
	 { "Fl_Counter_lstep", _wrap_Fl_Counter_lstep, METH_VARARGS, "Fl_Counter_lstep(Fl_Counter self, double a)"},
	 { "Fl_Counter_step", _wrap_Fl_Counter_step, METH_VARARGS, "\n"
		"Fl_Counter_step(Fl_Counter self, double a, double b)\n"
		"Fl_Counter_step(Fl_Counter self, double a)\n"
		"Fl_Counter_step(Fl_Counter self) -> double\n"
		""},
	 { "Fl_Counter_textfont", _wrap_Fl_Counter_textfont, METH_VARARGS, "\n"
		"Fl_Counter_textfont(Fl_Counter self) -> Fl_Font\n"
		"Fl_Counter_textfont(Fl_Counter self, Fl_Font s)\n"
		""},
	 { "Fl_Counter_textsize", _wrap_Fl_Counter_textsize, METH_VARARGS, "\n"
		"Fl_Counter_textsize(Fl_Counter self) -> Fl_Fontsize\n"
		"Fl_Counter_textsize(Fl_Counter self, Fl_Fontsize s)\n"
		""},
	 { "Fl_Counter_textcolor", _wrap_Fl_Counter_textcolor, METH_VARARGS, "\n"
		"Fl_Counter_textcolor(Fl_Counter self) -> Fl_Color\n"
		"Fl_Counter_textcolor(Fl_Counter self, Fl_Color s)\n"
		""},
	 { "Fl_Counter_init_type", _wrap_Fl_Counter_init_type, METH_VARARGS, "Fl_Counter_init_type(Fl_Counter self, char * Fl_Counter)"},
	 { "disown_Fl_Counter", _wrap_disown_Fl_Counter, METH_O, NULL},
	 { "Fl_Counter_swigregister", Fl_Counter_swigregister, METH_O, NULL},
	 { "Fl_Counter_swiginit", Fl_Counter_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Plugin", _wrap_new_Fl_Plugin, METH_VARARGS, "new_Fl_Plugin(PyObject * _self, char const * klass, char const * name) -> Fl_Plugin"},
	 { "delete_Fl_Plugin", _wrap_delete_Fl_Plugin, METH_O, "delete_Fl_Plugin(Fl_Plugin self)"},
	 { "disown_Fl_Plugin", _wrap_disown_Fl_Plugin, METH_O, NULL},
	 { "Fl_Plugin_swigregister", Fl_Plugin_swigregister, METH_O, NULL},
	 { "Fl_Plugin_swiginit", Fl_Plugin_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Plugin_Manager", _wrap_new_Fl_Plugin_Manager, METH_O, "new_Fl_Plugin_Manager(char const * klass) -> Fl_Plugin_Manager"},
	 { "delete_Fl_Plugin_Manager", _wrap_delete_Fl_Plugin_Manager, METH_O, "delete_Fl_Plugin_Manager(Fl_Plugin_Manager self)"},
	 { "Fl_Plugin_Manager_plugins", _wrap_Fl_Plugin_Manager_plugins, METH_O, "Fl_Plugin_Manager_plugins(Fl_Plugin_Manager self) -> int"},
	 { "Fl_Plugin_Manager_plugin", _wrap_Fl_Plugin_Manager_plugin, METH_VARARGS, "\n"
		"Fl_Plugin_Manager_plugin(Fl_Plugin_Manager self, int index) -> Fl_Plugin\n"
		"Fl_Plugin_Manager_plugin(Fl_Plugin_Manager self, char const * name) -> Fl_Plugin\n"
		""},
	 { "Fl_Plugin_Manager_addPlugin", _wrap_Fl_Plugin_Manager_addPlugin, METH_VARARGS, "Fl_Plugin_Manager_addPlugin(Fl_Plugin_Manager self, char const * name, Fl_Plugin plugin) -> Fl_Preferences::ID"},
	 { "Fl_Plugin_Manager_removePlugin", _wrap_Fl_Plugin_Manager_removePlugin, METH_O, "Fl_Plugin_Manager_removePlugin(Fl_Preferences::ID id)"},
	 { "Fl_Plugin_Manager_load", _wrap_Fl_Plugin_Manager_load, METH_O, "Fl_Plugin_Manager_load(char const * filename) -> int"},
	 { "Fl_Plugin_Manager_loadAll", _wrap_Fl_Plugin_Manager_loadAll, METH_VARARGS, "Fl_Plugin_Manager_loadAll(char const * dirpath, char const * pattern=None) -> int"},
	 { "Fl_Plugin_Manager_swigregister", Fl_Plugin_Manager_swigregister, METH_O, NULL},
	 { "Fl_Plugin_Manager_swiginit", Fl_Plugin_Manager_swiginit, METH_VARARGS, NULL},
	 { "Fl_Surface_Device_end_current", _wrap_Fl_Surface_Device_end_current, METH_O, "Fl_Surface_Device_end_current(Fl_Surface_Device self)"},
	 { "new_Fl_Surface_Device", _wrap_new_Fl_Surface_Device, METH_VARARGS, "new_Fl_Surface_Device(PyObject * _self, Fl_Graphics_Driver * graphics_driver) -> Fl_Surface_Device"},
	 { "Fl_Surface_Device_set_current", _wrap_Fl_Surface_Device_set_current, METH_O, "Fl_Surface_Device_set_current(Fl_Surface_Device self)"},
	 { "Fl_Surface_Device_is_current", _wrap_Fl_Surface_Device_is_current, METH_O, "Fl_Surface_Device_is_current(Fl_Surface_Device self) -> bool"},
	 { "Fl_Surface_Device_driver", _wrap_Fl_Surface_Device_driver, METH_O, "Fl_Surface_Device_driver(Fl_Surface_Device self) -> Fl_Graphics_Driver *"},
	 { "Fl_Surface_Device_surface", _wrap_Fl_Surface_Device_surface, METH_NOARGS, "Fl_Surface_Device_surface() -> Fl_Surface_Device"},
	 { "delete_Fl_Surface_Device", _wrap_delete_Fl_Surface_Device, METH_O, "delete_Fl_Surface_Device(Fl_Surface_Device self)"},
	 { "Fl_Surface_Device_push_current", _wrap_Fl_Surface_Device_push_current, METH_O, "Fl_Surface_Device_push_current(Fl_Surface_Device new_current)"},
	 { "Fl_Surface_Device_pop_current", _wrap_Fl_Surface_Device_pop_current, METH_NOARGS, "Fl_Surface_Device_pop_current() -> Fl_Surface_Device"},
	 { "disown_Fl_Surface_Device", _wrap_disown_Fl_Surface_Device, METH_O, NULL},
	 { "Fl_Surface_Device_swigregister", Fl_Surface_Device_swigregister, METH_O, NULL},
	 { "Fl_Surface_Device_swiginit", Fl_Surface_Device_swiginit, METH_VARARGS, NULL},
	 { "Fl_Display_Device_display_device", _wrap_Fl_Display_Device_display_device, METH_NOARGS, "Fl_Display_Device_display_device() -> Fl_Display_Device"},
	 { "delete_Fl_Display_Device", _wrap_delete_Fl_Display_Device, METH_O, "delete_Fl_Display_Device(Fl_Display_Device self)"},
	 { "disown_Fl_Display_Device", _wrap_disown_Fl_Display_Device, METH_O, NULL},
	 { "Fl_Display_Device_end_current", _wrap_Fl_Display_Device_end_current, METH_O, "Fl_Display_Device_end_current(Fl_Display_Device self)"},
	 { "Fl_Display_Device_swigregister", Fl_Display_Device_swigregister, METH_O, NULL},
	 { "new_Fl_Device_Plugin", _wrap_new_Fl_Device_Plugin, METH_VARARGS, "new_Fl_Device_Plugin(PyObject * _self, char const * pluginName) -> Fl_Device_Plugin"},
	 { "Fl_Device_Plugin_klass", _wrap_Fl_Device_Plugin_klass, METH_O, "Fl_Device_Plugin_klass(Fl_Device_Plugin self) -> char const *"},
	 { "Fl_Device_Plugin_name", _wrap_Fl_Device_Plugin_name, METH_O, "Fl_Device_Plugin_name(Fl_Device_Plugin self) -> char const *"},
	 { "Fl_Device_Plugin__print", _wrap_Fl_Device_Plugin__print, METH_VARARGS, "Fl_Device_Plugin__print(Fl_Device_Plugin self, Fl_Widget w) -> int"},
	 { "Fl_Device_Plugin_rectangle_capture", _wrap_Fl_Device_Plugin_rectangle_capture, METH_VARARGS, "Fl_Device_Plugin_rectangle_capture(Fl_Device_Plugin self, Fl_Widget widget, int x, int y, int w, int h) -> Fl_RGB_Image"},
	 { "delete_Fl_Device_Plugin", _wrap_delete_Fl_Device_Plugin, METH_O, "delete_Fl_Device_Plugin(Fl_Device_Plugin self)"},
	 { "disown_Fl_Device_Plugin", _wrap_disown_Fl_Device_Plugin, METH_O, NULL},
	 { "Fl_Device_Plugin_swigregister", Fl_Device_Plugin_swigregister, METH_O, NULL},
	 { "Fl_Device_Plugin_swiginit", Fl_Device_Plugin_swiginit, METH_VARARGS, NULL},
	 { "Fl_Dial_draw", _wrap_Fl_Dial_draw, METH_O, "Fl_Dial_draw(Fl_Dial self)"},
	 { "Fl_Dial_handle", _wrap_Fl_Dial_handle, METH_VARARGS, "Fl_Dial_handle(Fl_Dial self, int arg0) -> int"},
	 { "new_Fl_Dial", _wrap_new_Fl_Dial, METH_VARARGS, "new_Fl_Dial(PyObject * _self, int x, int y, int w, int h, char const * l=None) -> Fl_Dial"},
	 { "Fl_Dial_angle1", _wrap_Fl_Dial_angle1, METH_VARARGS, "\n"
		"Fl_Dial_angle1(Fl_Dial self) -> short\n"
		"Fl_Dial_angle1(Fl_Dial self, short a)\n"
		""},
	 { "Fl_Dial_angle2", _wrap_Fl_Dial_angle2, METH_VARARGS, "\n"
		"Fl_Dial_angle2(Fl_Dial self) -> short\n"
		"Fl_Dial_angle2(Fl_Dial self, short a)\n"
		""},
	 { "Fl_Dial_angles", _wrap_Fl_Dial_angles, METH_VARARGS, "Fl_Dial_angles(Fl_Dial self, short a, short b)"},
	 { "Fl_Dial_init_type", _wrap_Fl_Dial_init_type, METH_VARARGS, "Fl_Dial_init_type(Fl_Dial self, char * Fl_Dial)"},
	 { "delete_Fl_Dial", _wrap_delete_Fl_Dial, METH_O, "delete_Fl_Dial(Fl_Dial self)"},
	 { "disown_Fl_Dial", _wrap_disown_Fl_Dial, METH_O, NULL},
	 { "Fl_Dial_swigregister", Fl_Dial_swigregister, METH_O, NULL},
	 { "Fl_Dial_swiginit", Fl_Dial_swiginit, METH_VARARGS, NULL},
	 { "Fl_Window_draw", _wrap_Fl_Window_draw, METH_O, "Fl_Window_draw(Fl_Window self)"},
	 { "Fl_Window_flush", _wrap_Fl_Window_flush, METH_O, "Fl_Window_flush(Fl_Window self)"},
	 { "new_Fl_Window", _wrap_new_Fl_Window, METH_VARARGS, "\n"
		"Fl_Window(int w, int h, char const * title=None)\n"
		"new_Fl_Window(PyObject * _self, int x, int y, int w, int h, char const * title=None) -> Fl_Window\n"
		""},
	 { "delete_Fl_Window", _wrap_delete_Fl_Window, METH_O, "delete_Fl_Window(Fl_Window self)"},
	 { "Fl_Window_handle", _wrap_Fl_Window_handle, METH_VARARGS, "Fl_Window_handle(Fl_Window self, int arg0) -> int"},
	 { "Fl_Window_resize", _wrap_Fl_Window_resize, METH_VARARGS, "Fl_Window_resize(Fl_Window self, int X, int Y, int W, int H)"},
	 { "Fl_Window_clear_border", _wrap_Fl_Window_clear_border, METH_O, "Fl_Window_clear_border(Fl_Window self)"},
	 { "Fl_Window_border", _wrap_Fl_Window_border, METH_VARARGS, "\n"
		"Fl_Window_border(Fl_Window self, int b)\n"
		"Fl_Window_border(Fl_Window self) -> unsigned int\n"
		""},
	 { "Fl_Window_set_override", _wrap_Fl_Window_set_override, METH_O, "Fl_Window_set_override(Fl_Window self)"},
	 { "Fl_Window_override", _wrap_Fl_Window_override, METH_O, "Fl_Window_override(Fl_Window self) -> unsigned int"},
	 { "Fl_Window_set_modal", _wrap_Fl_Window_set_modal, METH_O, "Fl_Window_set_modal(Fl_Window self)"},
	 { "Fl_Window_modal", _wrap_Fl_Window_modal, METH_O, "Fl_Window_modal(Fl_Window self) -> unsigned int"},
	 { "Fl_Window_set_non_modal", _wrap_Fl_Window_set_non_modal, METH_O, "Fl_Window_set_non_modal(Fl_Window self)"},
	 { "Fl_Window_non_modal", _wrap_Fl_Window_non_modal, METH_O, "Fl_Window_non_modal(Fl_Window self) -> unsigned int"},
	 { "Fl_Window_clear_modal_states", _wrap_Fl_Window_clear_modal_states, METH_O, "Fl_Window_clear_modal_states(Fl_Window self)"},
	 { "Fl_Window_set_menu_window", _wrap_Fl_Window_set_menu_window, METH_O, "Fl_Window_set_menu_window(Fl_Window self)"},
	 { "Fl_Window_menu_window", _wrap_Fl_Window_menu_window, METH_O, "Fl_Window_menu_window(Fl_Window self) -> unsigned int"},
	 { "Fl_Window_set_tooltip_window", _wrap_Fl_Window_set_tooltip_window, METH_O, "Fl_Window_set_tooltip_window(Fl_Window self)"},
	 { "Fl_Window_tooltip_window", _wrap_Fl_Window_tooltip_window, METH_O, "Fl_Window_tooltip_window(Fl_Window self) -> unsigned int"},
	 { "Fl_Window_hotspot", _wrap_Fl_Window_hotspot, METH_VARARGS, "\n"
		"Fl_Window_hotspot(Fl_Window self, int x, int y, int offscreen=0)\n"
		"Fl_Window_hotspot(Fl_Window self, Fl_Widget arg2, int offscreen=0)\n"
		""},
	 { "Fl_Window_free_position", _wrap_Fl_Window_free_position, METH_O, "Fl_Window_free_position(Fl_Window self)"},
	 { "Fl_Window_size_range", _wrap_Fl_Window_size_range, METH_VARARGS, "Fl_Window_size_range(Fl_Window self, int minw, int minh, int maxw=0, int maxh=0, int dw=0, int dh=0, int aspect=0)"},
	 { "Fl_Window_get_size_range", _wrap_Fl_Window_get_size_range, METH_VARARGS, "Fl_Window_get_size_range(Fl_Window self, int * minw, int * minh, int * maxw=None, int * maxh=None, int * dw=None, int * dh=None, int * aspect=None) -> uchar"},
	 { "Fl_Window_iconlabel", _wrap_Fl_Window_iconlabel, METH_VARARGS, "\n"
		"Fl_Window_iconlabel(Fl_Window self) -> char const\n"
		"Fl_Window_iconlabel(Fl_Window self, char const * arg2)\n"
		""},
	 { "Fl_Window_label", _wrap_Fl_Window_label, METH_VARARGS, "\n"
		"Fl_Window_label(Fl_Window self) -> char const\n"
		"Fl_Window_label(Fl_Window self, char const * arg2)\n"
		"Fl_Window_label(Fl_Window self, char const * label, char const * iconlabel)\n"
		""},
	 { "Fl_Window_copy_label", _wrap_Fl_Window_copy_label, METH_VARARGS, "Fl_Window_copy_label(Fl_Window self, char const * a)"},
	 { "Fl_Window_default_xclass", _wrap_Fl_Window_default_xclass, METH_VARARGS, "\n"
		"Fl_Window_default_xclass(char const * arg1)\n"
		"Fl_Window_default_xclass() -> char const *\n"
		""},
	 { "Fl_Window_xclass", _wrap_Fl_Window_xclass, METH_VARARGS, "\n"
		"Fl_Window_xclass(Fl_Window self) -> char const\n"
		"Fl_Window_xclass(Fl_Window self, char const * c)\n"
		""},
	 { "Fl_Window_default_icon", _wrap_Fl_Window_default_icon, METH_O, "Fl_Window_default_icon(Fl_RGB_Image arg1)"},
	 { "Fl_Window_default_icons", _wrap_Fl_Window_default_icons, METH_VARARGS, "Fl_Window_default_icons(Fl_RGB_Image const *[] arg1, int arg2)"},
	 { "Fl_Window_icons", _wrap_Fl_Window_icons, METH_VARARGS, "Fl_Window_icons(Fl_Window self, Fl_RGB_Image const *[] arg2, int arg3)"},
	 { "Fl_Window_icon", _wrap_Fl_Window_icon, METH_VARARGS, "\n"
		"Fl_Window_icon(Fl_Window self, Fl_RGB_Image arg2)\n"
		"Fl_Window_icon(Fl_Window self) -> void const\n"
		"Fl_Window_icon(Fl_Window self, void const * ic)\n"
		""},
	 { "Fl_Window_shown", _wrap_Fl_Window_shown, METH_O, "Fl_Window_shown(Fl_Window self) -> int"},
	 { "Fl_Window_hide", _wrap_Fl_Window_hide, METH_O, "Fl_Window_hide(Fl_Window self)"},
	 { "Fl_Window_wait_for_expose", _wrap_Fl_Window_wait_for_expose, METH_O, "Fl_Window_wait_for_expose(Fl_Window self)"},
	 { "Fl_Window_fullscreen", _wrap_Fl_Window_fullscreen, METH_O, "Fl_Window_fullscreen(Fl_Window self)"},
	 { "Fl_Window_fullscreen_off", _wrap_Fl_Window_fullscreen_off, METH_VARARGS, "\n"
		"Fl_Window_fullscreen_off(Fl_Window self)\n"
		"Fl_Window_fullscreen_off(Fl_Window self, int X, int Y, int W, int H)\n"
		""},
	 { "Fl_Window_fullscreen_active", _wrap_Fl_Window_fullscreen_active, METH_O, "Fl_Window_fullscreen_active(Fl_Window self) -> unsigned int"},
	 { "Fl_Window_fullscreen_screens", _wrap_Fl_Window_fullscreen_screens, METH_VARARGS, "Fl_Window_fullscreen_screens(Fl_Window self, int top, int bottom, int left, int right)"},
	 { "Fl_Window_maximize", _wrap_Fl_Window_maximize, METH_O, "Fl_Window_maximize(Fl_Window self)"},
	 { "Fl_Window_un_maximize", _wrap_Fl_Window_un_maximize, METH_O, "Fl_Window_un_maximize(Fl_Window self)"},
	 { "Fl_Window_maximize_active", _wrap_Fl_Window_maximize_active, METH_O, "Fl_Window_maximize_active(Fl_Window self) -> unsigned int"},
	 { "Fl_Window_iconize", _wrap_Fl_Window_iconize, METH_O, "Fl_Window_iconize(Fl_Window self)"},
	 { "Fl_Window_x_root", _wrap_Fl_Window_x_root, METH_O, "Fl_Window_x_root(Fl_Window self) -> int"},
	 { "Fl_Window_y_root", _wrap_Fl_Window_y_root, METH_O, "Fl_Window_y_root(Fl_Window self) -> int"},
	 { "Fl_Window_current", _wrap_Fl_Window_current, METH_NOARGS, "Fl_Window_current() -> Fl_Window"},
	 { "Fl_Window_make_current", _wrap_Fl_Window_make_current, METH_O, "Fl_Window_make_current(Fl_Window self)"},
	 { "Fl_Window_cursor", _wrap_Fl_Window_cursor, METH_VARARGS, "\n"
		"Fl_Window_cursor(Fl_Window self, Fl_Cursor arg2)\n"
		"Fl_Window_cursor(Fl_Window self, Fl_RGB_Image arg2, int arg3, int arg4)\n"
		"Fl_Window_cursor(Fl_Window self, Fl_Cursor c, Fl_Color arg3, Fl_Color arg4=)\n"
		""},
	 { "Fl_Window_default_cursor", _wrap_Fl_Window_default_cursor, METH_VARARGS, "\n"
		"Fl_Window_default_cursor(Fl_Window self, Fl_Cursor arg2)\n"
		"Fl_Window_default_cursor(Fl_Window self, Fl_Cursor c, Fl_Color arg3, Fl_Color arg4=)\n"
		""},
	 { "Fl_Window_default_callback", _wrap_Fl_Window_default_callback, METH_VARARGS, "Fl_Window_default_callback(Fl_Window arg1, void * v)"},
	 { "Fl_Window_decorated_w", _wrap_Fl_Window_decorated_w, METH_O, "Fl_Window_decorated_w(Fl_Window self) -> int"},
	 { "Fl_Window_decorated_h", _wrap_Fl_Window_decorated_h, METH_O, "Fl_Window_decorated_h(Fl_Window self) -> int"},
	 { "Fl_Window_as_window", _wrap_Fl_Window_as_window, METH_VARARGS, "\n"
		"Fl_Window_as_window(Fl_Window self) -> Fl_Window\n"
		"Fl_Window_as_window(Fl_Window self) -> Fl_Window\n"
		""},
	 { "Fl_Window_as_overlay_window", _wrap_Fl_Window_as_overlay_window, METH_O, "Fl_Window_as_overlay_window(Fl_Window self) -> Fl_Overlay_Window"},
	 { "Fl_Window_as_double_window", _wrap_Fl_Window_as_double_window, METH_O, "Fl_Window_as_double_window(Fl_Window self) -> Fl_Double_Window"},
	 { "Fl_Window_shape", _wrap_Fl_Window_shape, METH_VARARGS, "\n"
		"Fl_Window_shape(Fl_Window self, Fl_Image img)\n"
		"Fl_Window_shape(Fl_Window self, Fl_Image b)\n"
		"Fl_Window_shape(Fl_Window self) -> Fl_Image\n"
		""},
	 { "Fl_Window_draw_backdrop", _wrap_Fl_Window_draw_backdrop, METH_O, "Fl_Window_draw_backdrop(Fl_Window self)"},
	 { "Fl_Window_screen_num", _wrap_Fl_Window_screen_num, METH_VARARGS, "\n"
		"Fl_Window_screen_num(Fl_Window self) -> int\n"
		"Fl_Window_screen_num(Fl_Window self, int screen_num)\n"
		""},
	 { "Fl_Window_is_a_rescale", _wrap_Fl_Window_is_a_rescale, METH_NOARGS, "Fl_Window_is_a_rescale() -> bool"},
	 { "Fl_Window_os_id", _wrap_Fl_Window_os_id, METH_O, "Fl_Window_os_id(Fl_Window self) -> fl_uintptr_t"},
	 { "Fl_Window_show_next_window_iconic", _wrap_Fl_Window_show_next_window_iconic, METH_VARARGS, "\n"
		"Fl_Window_show_next_window_iconic(char stat)\n"
		"Fl_Window_show_next_window_iconic() -> char\n"
		""},
	 { "Fl_Window_allow_expand_outside_parent", _wrap_Fl_Window_allow_expand_outside_parent, METH_O, "Fl_Window_allow_expand_outside_parent(Fl_Window self)"},
	 { "Fl_Window_init_type", _wrap_Fl_Window_init_type, METH_VARARGS, "Fl_Window_init_type(Fl_Window self, char * Fl_Window)"},
	 { "Fl_Window_show", _wrap_Fl_Window_show, METH_VARARGS, "Fl_Window_show(Fl_Window self, PyObject * count=None, PyObject * data=None)"},
	 { "disown_Fl_Window", _wrap_disown_Fl_Window, METH_O, NULL},
	 { "Fl_Window_swigregister", Fl_Window_swigregister, METH_O, NULL},
	 { "Fl_Window_swiginit", Fl_Window_swiginit, METH_VARARGS, NULL},
	 { "Fl_Double_Window_as_double_window", _wrap_Fl_Double_Window_as_double_window, METH_O, "Fl_Double_Window_as_double_window(Fl_Double_Window self) -> Fl_Double_Window"},
	 { "Fl_Double_Window_resize", _wrap_Fl_Double_Window_resize, METH_VARARGS, "Fl_Double_Window_resize(Fl_Double_Window self, int arg0, int arg1, int arg2, int arg3)"},
	 { "Fl_Double_Window_hide", _wrap_Fl_Double_Window_hide, METH_O, "Fl_Double_Window_hide(Fl_Double_Window self)"},
	 { "Fl_Double_Window_flush", _wrap_Fl_Double_Window_flush, METH_O, "Fl_Double_Window_flush(Fl_Double_Window self)"},
	 { "delete_Fl_Double_Window", _wrap_delete_Fl_Double_Window, METH_O, "delete_Fl_Double_Window(Fl_Double_Window self)"},
	 { "new_Fl_Double_Window", _wrap_new_Fl_Double_Window, METH_VARARGS, "\n"
		"Fl_Double_Window(int W, int H, char const * l=None)\n"
		"new_Fl_Double_Window(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Double_Window\n"
		""},
	 { "Fl_Double_Window_init_type", _wrap_Fl_Double_Window_init_type, METH_VARARGS, "Fl_Double_Window_init_type(Fl_Double_Window self, char * Fl_Double_Window)"},
	 { "Fl_Double_Window_show", _wrap_Fl_Double_Window_show, METH_VARARGS, "Fl_Double_Window_show(Fl_Double_Window self, PyObject * count=None, PyObject * data=None)"},
	 { "disown_Fl_Double_Window", _wrap_disown_Fl_Double_Window, METH_O, NULL},
	 { "Fl_Double_Window_draw", _wrap_Fl_Double_Window_draw, METH_O, "Fl_Double_Window_draw(Fl_Double_Window self)"},
	 { "Fl_Double_Window_swigregister", Fl_Double_Window_swigregister, METH_O, NULL},
	 { "Fl_Double_Window_swiginit", Fl_Double_Window_swiginit, METH_VARARGS, NULL},
	 { "fl_color", _wrap_fl_color, METH_VARARGS, "\n"
		"fl_color(Fl_Color c)\n"
		"fl_color(uchar r, uchar g, uchar b)\n"
		"fl_color() -> Fl_Color\n"
		""},
	 { "fl_push_clip", _wrap_fl_push_clip, METH_VARARGS, "fl_push_clip(int x, int y, int w, int h)"},
	 { "fl_push_no_clip", _wrap_fl_push_no_clip, METH_NOARGS, "fl_push_no_clip()"},
	 { "fl_pop_clip", _wrap_fl_pop_clip, METH_NOARGS, "fl_pop_clip()"},
	 { "fl_not_clipped", _wrap_fl_not_clipped, METH_VARARGS, "fl_not_clipped(int x, int y, int w, int h) -> int"},
	 { "fl_clip_box", _wrap_fl_clip_box, METH_VARARGS, "fl_clip_box(int x, int y, int w, int h) -> int"},
	 { "fl_restore_clip", _wrap_fl_restore_clip, METH_NOARGS, "fl_restore_clip()"},
	 { "fl_clip_region", _wrap_fl_clip_region, METH_VARARGS, "\n"
		"fl_clip_region(Fl_Region r)\n"
		"fl_clip_region() -> Fl_Region\n"
		""},
	 { "fl_point", _wrap_fl_point, METH_VARARGS, "fl_point(int x, int y)"},
	 { "fl_line_style", _wrap_fl_line_style, METH_VARARGS, "fl_line_style(int style, int width=0, char * dashes=None)"},
	 { "fl_antialias", _wrap_fl_antialias, METH_VARARGS, "\n"
		"fl_antialias(int state)\n"
		"fl_antialias() -> int\n"
		""},
	 { "fl_rounded_rect", _wrap_fl_rounded_rect, METH_VARARGS, "fl_rounded_rect(int x, int y, int w, int h, int r)"},
	 { "fl_focus_rect", _wrap_fl_focus_rect, METH_VARARGS, "fl_focus_rect(int x, int y, int w, int h)"},
	 { "fl_rect", _wrap_fl_rect, METH_VARARGS, "\n"
		"fl_rect(int x, int y, int w, int h)\n"
		"fl_rect(Fl_Rect r)\n"
		"fl_rect(int x, int y, int w, int h, Fl_Color c)\n"
		""},
	 { "fl_rounded_rectf", _wrap_fl_rounded_rectf, METH_VARARGS, "fl_rounded_rectf(int x, int y, int w, int h, int r)"},
	 { "fl_rectf", _wrap_fl_rectf, METH_VARARGS, "\n"
		"fl_rectf(int x, int y, int w, int h)\n"
		"fl_rectf(int x, int y, int w, int h, Fl_Color c)\n"
		"fl_rectf(Fl_Rect r)\n"
		"fl_rectf(Fl_Rect r, Fl_Color c)\n"
		"fl_rectf(int x, int y, int w, int h, uchar r, uchar g, uchar b)\n"
		"fl_rectf(Fl_Rect bb, uchar r, uchar g, uchar b)\n"
		""},
	 { "fl_line", _wrap_fl_line, METH_VARARGS, "\n"
		"fl_line(int x, int y, int x1, int y1)\n"
		"fl_line(int x, int y, int x1, int y1, int x2, int y2)\n"
		""},
	 { "fl_loop", _wrap_fl_loop, METH_VARARGS, "\n"
		"fl_loop(int x, int y, int x1, int y1, int x2, int y2)\n"
		"fl_loop(int x, int y, int x1, int y1, int x2, int y2, int x3, int y3)\n"
		""},
	 { "fl_polygon", _wrap_fl_polygon, METH_VARARGS, "\n"
		"fl_polygon(int x, int y, int x1, int y1, int x2, int y2)\n"
		"fl_polygon(int x, int y, int x1, int y1, int x2, int y2, int x3, int y3)\n"
		""},
	 { "fl_xyline", _wrap_fl_xyline, METH_VARARGS, "\n"
		"fl_xyline(int x, int y, int x1)\n"
		"fl_xyline(int x, int y, int x1, int y2)\n"
		"fl_xyline(int x, int y, int x1, int y2, int x3)\n"
		""},
	 { "fl_yxline", _wrap_fl_yxline, METH_VARARGS, "\n"
		"fl_yxline(int x, int y, int y1)\n"
		"fl_yxline(int x, int y, int y1, int x2)\n"
		"fl_yxline(int x, int y, int y1, int x2, int y3)\n"
		""},
	 { "fl_pie", _wrap_fl_pie, METH_VARARGS, "fl_pie(int x, int y, int w, int h, double a1, double a2)"},
	 { "fl_push_matrix", _wrap_fl_push_matrix, METH_NOARGS, "fl_push_matrix()"},
	 { "fl_pop_matrix", _wrap_fl_pop_matrix, METH_NOARGS, "fl_pop_matrix()"},
	 { "fl_scale", _wrap_fl_scale, METH_VARARGS, "\n"
		"fl_scale(double x, double y)\n"
		"fl_scale(double x)\n"
		""},
	 { "fl_translate", _wrap_fl_translate, METH_VARARGS, "fl_translate(double x, double y)"},
	 { "fl_rotate", _wrap_fl_rotate, METH_O, "fl_rotate(double d)"},
	 { "fl_load_identity", _wrap_fl_load_identity, METH_NOARGS, "fl_load_identity()"},
	 { "fl_load_matrix", _wrap_fl_load_matrix, METH_VARARGS, "fl_load_matrix(double a, double b, double c, double d, double x, double y)"},
	 { "fl_mult_matrix", _wrap_fl_mult_matrix, METH_VARARGS, "fl_mult_matrix(double a, double b, double c, double d, double x, double y)"},
	 { "fl_begin_points", _wrap_fl_begin_points, METH_NOARGS, "fl_begin_points()"},
	 { "fl_begin_line", _wrap_fl_begin_line, METH_NOARGS, "fl_begin_line()"},
	 { "fl_begin_loop", _wrap_fl_begin_loop, METH_NOARGS, "fl_begin_loop()"},
	 { "fl_begin_polygon", _wrap_fl_begin_polygon, METH_NOARGS, "fl_begin_polygon()"},
	 { "fl_vertex", _wrap_fl_vertex, METH_VARARGS, "fl_vertex(double x, double y)"},
	 { "fl_curve", _wrap_fl_curve, METH_VARARGS, "fl_curve(double X0, double Y0, double X1, double Y1, double X2, double Y2, double X3, double Y3)"},
	 { "fl_arc", _wrap_fl_arc, METH_VARARGS, "\n"
		"fl_arc(int x, int y, int w, int h, double a1, double a2)\n"
		"fl_arc(double x, double y, double r, double start, double end)\n"
		""},
	 { "fl_circle", _wrap_fl_circle, METH_VARARGS, "fl_circle(double x, double y, double r)"},
	 { "fl_end_points", _wrap_fl_end_points, METH_NOARGS, "fl_end_points()"},
	 { "fl_end_line", _wrap_fl_end_line, METH_NOARGS, "fl_end_line()"},
	 { "fl_end_loop", _wrap_fl_end_loop, METH_NOARGS, "fl_end_loop()"},
	 { "fl_end_polygon", _wrap_fl_end_polygon, METH_NOARGS, "fl_end_polygon()"},
	 { "fl_begin_complex_polygon", _wrap_fl_begin_complex_polygon, METH_NOARGS, "fl_begin_complex_polygon()"},
	 { "fl_gap", _wrap_fl_gap, METH_NOARGS, "fl_gap()"},
	 { "fl_end_complex_polygon", _wrap_fl_end_complex_polygon, METH_NOARGS, "fl_end_complex_polygon()"},
	 { "fl_transform_x", _wrap_fl_transform_x, METH_VARARGS, "fl_transform_x(double x, double y) -> double"},
	 { "fl_transform_y", _wrap_fl_transform_y, METH_VARARGS, "fl_transform_y(double x, double y) -> double"},
	 { "fl_transform_dx", _wrap_fl_transform_dx, METH_VARARGS, "fl_transform_dx(double x, double y) -> double"},
	 { "fl_transform_dy", _wrap_fl_transform_dy, METH_VARARGS, "fl_transform_dy(double x, double y) -> double"},
	 { "fl_transformed_vertex", _wrap_fl_transformed_vertex, METH_VARARGS, "fl_transformed_vertex(double xf, double yf)"},
	 { "fl_copy_offscreen", _wrap_fl_copy_offscreen, METH_VARARGS, "fl_copy_offscreen(int x, int y, int w, int h, Fl_Offscreen pixmap, int srcx, int srcy)"},
	 { "fl_create_offscreen", _wrap_fl_create_offscreen, METH_VARARGS, "fl_create_offscreen(int w, int h) -> Fl_Offscreen"},
	 { "fl_begin_offscreen", _wrap_fl_begin_offscreen, METH_O, "fl_begin_offscreen(Fl_Offscreen b)"},
	 { "fl_end_offscreen", _wrap_fl_end_offscreen, METH_NOARGS, "fl_end_offscreen()"},
	 { "fl_delete_offscreen", _wrap_fl_delete_offscreen, METH_O, "fl_delete_offscreen(Fl_Offscreen bitmap)"},
	 { "fl_rescale_offscreen", _wrap_fl_rescale_offscreen, METH_O, "fl_rescale_offscreen(Fl_Offscreen & ctx)"},
	 { "fl_font", _wrap_fl_font, METH_VARARGS, "\n"
		"fl_font(Fl_Font face, Fl_Fontsize fsize)\n"
		"fl_font() -> Fl_Font\n"
		""},
	 { "fl_size", _wrap_fl_size, METH_NOARGS, "fl_size() -> Fl_Fontsize"},
	 { "fl_height", _wrap_fl_height, METH_VARARGS, "\n"
		"fl_height() -> int\n"
		"fl_height(int font, int size) -> int\n"
		""},
	 { "fl_descent", _wrap_fl_descent, METH_NOARGS, "fl_descent() -> int"},
	 { "fl_width", _wrap_fl_width, METH_VARARGS, "\n"
		"fl_width(char const * txt) -> double\n"
		"fl_width(char const * txt, int n) -> double\n"
		"fl_width(unsigned int c) -> double\n"
		""},
	 { "fl_text_extents", _wrap_fl_text_extents, METH_VARARGS, "\n"
		"fl_text_extents(char const * arg1)\n"
		"fl_text_extents(char const * t, int n)\n"
		""},
	 { "fl_latin1_to_local", _wrap_fl_latin1_to_local, METH_VARARGS, "fl_latin1_to_local(char const * t, int n=-1) -> char const *"},
	 { "fl_local_to_latin1", _wrap_fl_local_to_latin1, METH_VARARGS, "fl_local_to_latin1(char const * t, int n=-1) -> char const *"},
	 { "fl_mac_roman_to_local", _wrap_fl_mac_roman_to_local, METH_VARARGS, "fl_mac_roman_to_local(char const * t, int n=-1) -> char const *"},
	 { "fl_local_to_mac_roman", _wrap_fl_local_to_mac_roman, METH_VARARGS, "fl_local_to_mac_roman(char const * t, int n=-1) -> char const *"},
	 { "fl_override_scale", _wrap_fl_override_scale, METH_NOARGS, "fl_override_scale() -> float"},
	 { "fl_restore_scale", _wrap_fl_restore_scale, METH_O, "fl_restore_scale(float s)"},
	 { "fl_rtl_draw", _wrap_fl_rtl_draw, METH_VARARGS, "fl_rtl_draw(char const * str, int n, int x, int y)"},
	 { "fl_draw", _wrap_fl_draw, METH_VARARGS, "\n"
		"fl_draw(char const * str, int x, int y)\n"
		"fl_draw(int angle, char const * str, int x, int y)\n"
		"fl_draw(char const * str, int n, int x, int y)\n"
		"fl_draw(int angle, char const * str, int n, int x, int y)\n"
		"fl_draw(char const * str, int x, int y, int w, int h, Fl_Align align, Fl_Image img=None, int draw_symbols=1, int spacing=0)\n"
		"fl_draw(char const * str, int x, int y, int w, int h, Fl_Align align, void (*)(char const *,int,int,int) callthis, Fl_Image img=None, int draw_symbols=1, int spacing=0)\n"
		""},
	 { "fl_frame", _wrap_fl_frame, METH_VARARGS, "\n"
		"fl_frame(Fl_Boxtype b) -> Fl_Boxtype\n"
		"fl_frame(char const * s, int x, int y, int w, int h)\n"
		""},
	 { "fl_frame2", _wrap_fl_frame2, METH_VARARGS, "fl_frame2(char const * s, int x, int y, int w, int h)"},
	 { "fl_draw_box", _wrap_fl_draw_box, METH_VARARGS, "fl_draw_box(Fl_Boxtype arg1, int x, int y, int w, int h, Fl_Color arg6)"},
	 { "fl_draw_box_focus", _wrap_fl_draw_box_focus, METH_VARARGS, "fl_draw_box_focus(Fl_Boxtype arg1, int x, int y, int w, int h, Fl_Color arg6, Fl_Color arg7)"},
	 { "fl_draw_arrow", _wrap_fl_draw_arrow, METH_VARARGS, "fl_draw_arrow(Fl_Rect bb, Fl_Arrow_Type t, Fl_Orientation o, Fl_Color color)"},
	 { "fl_draw_circle", _wrap_fl_draw_circle, METH_VARARGS, "fl_draw_circle(int x, int y, int d, Fl_Color color)"},
	 { "fl_draw_radio", _wrap_fl_draw_radio, METH_VARARGS, "fl_draw_radio(int x, int y, int d, Fl_Color color)"},
	 { "fl_draw_image", _wrap_fl_draw_image, METH_VARARGS, "fl_draw_image(uchar const * buf, int X, int Y, int W, int H, int D=3, int L=0)"},
	 { "fl_draw_image_mono", _wrap_fl_draw_image_mono, METH_VARARGS, "fl_draw_image_mono(uchar const * buf, int X, int Y, int W, int H, int D=1, int L=0)"},
	 { "fl_can_do_alpha_blending", _wrap_fl_can_do_alpha_blending, METH_NOARGS, "fl_can_do_alpha_blending() -> char"},
	 { "fl_capture_window", _wrap_fl_capture_window, METH_VARARGS, "fl_capture_window(Fl_Window win, int x, int y, int w, int h) -> Fl_RGB_Image"},
	 { "fl_draw_pixmap", _wrap_fl_draw_pixmap, METH_VARARGS, "fl_draw_pixmap(char *const * data, int x, int y, Fl_Color bg=) -> int"},
	 { "fl_measure_pixmap", _wrap_fl_measure_pixmap, METH_O, "fl_measure_pixmap(char *const * data) -> int"},
	 { "fl_scroll", _wrap_fl_scroll, METH_VARARGS, "fl_scroll(int X, int Y, int W, int H, int dx, int dy, void (*)(void *,int,int,int,int) draw_area, void * data)"},
	 { "fl_shortcut_label", _wrap_fl_shortcut_label, METH_VARARGS, "\n"
		"fl_shortcut_label(unsigned int shortcut) -> char const\n"
		"fl_shortcut_label(unsigned int shortcut, char const ** eom) -> char const *\n"
		""},
	 { "fl_old_shortcut", _wrap_fl_old_shortcut, METH_O, "fl_old_shortcut(char const * s) -> unsigned int"},
	 { "fl_overlay_rect", _wrap_fl_overlay_rect, METH_VARARGS, "fl_overlay_rect(int x, int y, int w, int h)"},
	 { "fl_overlay_clear", _wrap_fl_overlay_clear, METH_NOARGS, "fl_overlay_clear()"},
	 { "fl_cursor", _wrap_fl_cursor, METH_VARARGS, "\n"
		"fl_cursor(Fl_Cursor arg1)\n"
		"fl_cursor(Fl_Cursor arg1, Fl_Color fg, Fl_Color bg=)\n"
		""},
	 { "fl_expand_text", _wrap_fl_expand_text, METH_VARARGS, "fl_expand_text(char const * _from, char * buf, int maxbuf, double maxw, double & width, int wrap, int draw_symbols=0) -> char const *"},
	 { "fl_set_status", _wrap_fl_set_status, METH_VARARGS, "fl_set_status(int X, int Y, int W, int H)"},
	 { "fl_set_spot", _wrap_fl_set_spot, METH_VARARGS, "fl_set_spot(int font, int size, int X, int Y, int W, int H, Fl_Window win=None)"},
	 { "fl_reset_spot", _wrap_fl_reset_spot, METH_NOARGS, "fl_reset_spot()"},
	 { "fl_draw_symbol", _wrap_fl_draw_symbol, METH_VARARGS, "fl_draw_symbol(char const * label, int x, int y, int w, int h, Fl_Color arg6) -> int"},
	 { "fl_add_symbol", _wrap_fl_add_symbol, METH_VARARGS, "fl_add_symbol(char const * name, void (*)(Fl_Color) drawit, int scalable) -> int"},
	 { "fl_measure", _wrap_fl_measure, METH_VARARGS, "fl_measure(char const * str, int draw_symbols=1)"},
	 { "Fl_Input__resize", _wrap_Fl_Input__resize, METH_VARARGS, "Fl_Input__resize(Fl_Input_ self, int arg0, int arg1, int arg2, int arg3)"},
	 { "new_Fl_Input_", _wrap_new_Fl_Input_, METH_VARARGS, "new_Fl_Input_(PyObject * _self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Input_"},
	 { "delete_Fl_Input_", _wrap_delete_Fl_Input_, METH_O, "delete_Fl_Input_(Fl_Input_ self)"},
	 { "Fl_Input__static_value", _wrap_Fl_Input__static_value, METH_VARARGS, "\n"
		"Fl_Input__static_value(Fl_Input_ self, char const * arg2) -> int\n"
		"Fl_Input__static_value(Fl_Input_ self, char const * arg2, int arg3) -> int\n"
		""},
	 { "Fl_Input__value", _wrap_Fl_Input__value, METH_VARARGS, "\n"
		"Fl_Input__value(Fl_Input_ self, char const * arg2) -> int\n"
		"Fl_Input__value(Fl_Input_ self, char const * arg2, int arg3) -> int\n"
		"Fl_Input__value(Fl_Input_ self, int value) -> int\n"
		"Fl_Input__value(Fl_Input_ self, double value) -> int\n"
		"Fl_Input__value(Fl_Input_ self) -> char const *\n"
		""},
	 { "Fl_Input__ivalue", _wrap_Fl_Input__ivalue, METH_O, "Fl_Input__ivalue(Fl_Input_ self) -> int"},
	 { "Fl_Input__dvalue", _wrap_Fl_Input__dvalue, METH_O, "Fl_Input__dvalue(Fl_Input_ self) -> double"},
	 { "Fl_Input__index", _wrap_Fl_Input__index, METH_VARARGS, "Fl_Input__index(Fl_Input_ self, int i) -> unsigned int"},
	 { "Fl_Input__size", _wrap_Fl_Input__size, METH_VARARGS, "\n"
		"Fl_Input__size(Fl_Input_ self) -> int\n"
		"Fl_Input__size(Fl_Input_ self, int W, int H)\n"
		""},
	 { "Fl_Input__maximum_size", _wrap_Fl_Input__maximum_size, METH_VARARGS, "\n"
		"Fl_Input__maximum_size(Fl_Input_ self) -> int\n"
		"Fl_Input__maximum_size(Fl_Input_ self, int m)\n"
		""},
	 { "Fl_Input__insert_position", _wrap_Fl_Input__insert_position, METH_VARARGS, "\n"
		"Fl_Input__insert_position(Fl_Input_ self) -> int\n"
		"Fl_Input__insert_position(Fl_Input_ self, int p, int m) -> int\n"
		"Fl_Input__insert_position(Fl_Input_ self, int p) -> int\n"
		""},
	 { "Fl_Input__mark", _wrap_Fl_Input__mark, METH_VARARGS, "\n"
		"Fl_Input__mark(Fl_Input_ self) -> int\n"
		"Fl_Input__mark(Fl_Input_ self, int m) -> int\n"
		""},
	 { "Fl_Input__replace", _wrap_Fl_Input__replace, METH_VARARGS, "Fl_Input__replace(Fl_Input_ self, int b, int e, char const * text, int ilen=0) -> int"},
	 { "Fl_Input__cut", _wrap_Fl_Input__cut, METH_VARARGS, "\n"
		"Fl_Input__cut(Fl_Input_ self) -> int\n"
		"Fl_Input__cut(Fl_Input_ self, int n) -> int\n"
		"Fl_Input__cut(Fl_Input_ self, int a, int b) -> int\n"
		""},
	 { "Fl_Input__insert", _wrap_Fl_Input__insert, METH_VARARGS, "Fl_Input__insert(Fl_Input_ self, char const * t, int l=0) -> int"},
	 { "Fl_Input__append", _wrap_Fl_Input__append, METH_VARARGS, "Fl_Input__append(Fl_Input_ self, char const * t, int l=0, char keep_selection=0) -> int"},
	 { "Fl_Input__copy", _wrap_Fl_Input__copy, METH_VARARGS, "Fl_Input__copy(Fl_Input_ self, int clipboard) -> int"},
	 { "Fl_Input__undo", _wrap_Fl_Input__undo, METH_O, "Fl_Input__undo(Fl_Input_ self) -> int"},
	 { "Fl_Input__can_undo", _wrap_Fl_Input__can_undo, METH_O, "Fl_Input__can_undo(Fl_Input_ self) -> bool"},
	 { "Fl_Input__redo", _wrap_Fl_Input__redo, METH_O, "Fl_Input__redo(Fl_Input_ self) -> int"},
	 { "Fl_Input__can_redo", _wrap_Fl_Input__can_redo, METH_O, "Fl_Input__can_redo(Fl_Input_ self) -> bool"},
	 { "Fl_Input__copy_cuts", _wrap_Fl_Input__copy_cuts, METH_O, "Fl_Input__copy_cuts(Fl_Input_ self) -> int"},
	 { "Fl_Input__shortcut", _wrap_Fl_Input__shortcut, METH_VARARGS, "\n"
		"Fl_Input__shortcut(Fl_Input_ self) -> int\n"
		"Fl_Input__shortcut(Fl_Input_ self, int s)\n"
		""},
	 { "Fl_Input__textfont", _wrap_Fl_Input__textfont, METH_VARARGS, "\n"
		"Fl_Input__textfont(Fl_Input_ self) -> Fl_Font\n"
		"Fl_Input__textfont(Fl_Input_ self, Fl_Font s)\n"
		""},
	 { "Fl_Input__textsize", _wrap_Fl_Input__textsize, METH_VARARGS, "\n"
		"Fl_Input__textsize(Fl_Input_ self) -> Fl_Fontsize\n"
		"Fl_Input__textsize(Fl_Input_ self, Fl_Fontsize s)\n"
		""},
	 { "Fl_Input__textcolor", _wrap_Fl_Input__textcolor, METH_VARARGS, "\n"
		"Fl_Input__textcolor(Fl_Input_ self) -> Fl_Color\n"
		"Fl_Input__textcolor(Fl_Input_ self, Fl_Color n)\n"
		""},
	 { "Fl_Input__cursor_color", _wrap_Fl_Input__cursor_color, METH_VARARGS, "\n"
		"Fl_Input__cursor_color(Fl_Input_ self) -> Fl_Color\n"
		"Fl_Input__cursor_color(Fl_Input_ self, Fl_Color n)\n"
		""},
	 { "Fl_Input__input_type", _wrap_Fl_Input__input_type, METH_VARARGS, "\n"
		"Fl_Input__input_type(Fl_Input_ self) -> int\n"
		"Fl_Input__input_type(Fl_Input_ self, int t)\n"
		""},
	 { "Fl_Input__readonly", _wrap_Fl_Input__readonly, METH_VARARGS, "\n"
		"Fl_Input__readonly(Fl_Input_ self) -> int\n"
		"Fl_Input__readonly(Fl_Input_ self, int b)\n"
		""},
	 { "Fl_Input__wrap", _wrap_Fl_Input__wrap, METH_VARARGS, "\n"
		"Fl_Input__wrap(Fl_Input_ self) -> int\n"
		"Fl_Input__wrap(Fl_Input_ self, int b)\n"
		""},
	 { "Fl_Input__tab_nav", _wrap_Fl_Input__tab_nav, METH_VARARGS, "\n"
		"Fl_Input__tab_nav(Fl_Input_ self, int val)\n"
		"Fl_Input__tab_nav(Fl_Input_ self) -> int\n"
		""},
	 { "Fl_Input__init_type", _wrap_Fl_Input__init_type, METH_VARARGS, "Fl_Input__init_type(Fl_Input_ self, char * Fl_Input_)"},
	 { "disown_Fl_Input_", _wrap_disown_Fl_Input_, METH_O, NULL},
	 { "Fl_Input__swigregister", Fl_Input__swigregister, METH_O, NULL},
	 { "Fl_Input__swiginit", Fl_Input__swiginit, METH_VARARGS, NULL},
	 { "Fl_Input_draw", _wrap_Fl_Input_draw, METH_O, "Fl_Input_draw(Fl_Input self)"},
	 { "Fl_Input_handle", _wrap_Fl_Input_handle, METH_VARARGS, "Fl_Input_handle(Fl_Input self, int arg0) -> int"},
	 { "new_Fl_Input", _wrap_new_Fl_Input, METH_VARARGS, "new_Fl_Input(PyObject * _self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Input"},
	 { "Fl_Input_init_type", _wrap_Fl_Input_init_type, METH_VARARGS, "Fl_Input_init_type(Fl_Input self, char * Fl_Input)"},
	 { "delete_Fl_Input", _wrap_delete_Fl_Input, METH_O, "delete_Fl_Input(Fl_Input self)"},
	 { "disown_Fl_Input", _wrap_disown_Fl_Input, METH_O, NULL},
	 { "Fl_Input_swigregister", Fl_Input_swigregister, METH_O, NULL},
	 { "Fl_Input_swiginit", Fl_Input_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_File_Input", _wrap_new_Fl_File_Input, METH_VARARGS, "new_Fl_File_Input(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_File_Input"},
	 { "Fl_File_Input_handle", _wrap_Fl_File_Input_handle, METH_VARARGS, "Fl_File_Input_handle(Fl_File_Input self, int event) -> int"},
	 { "Fl_File_Input_draw", _wrap_Fl_File_Input_draw, METH_O, "Fl_File_Input_draw(Fl_File_Input self)"},
	 { "Fl_File_Input_down_box", _wrap_Fl_File_Input_down_box, METH_VARARGS, "\n"
		"Fl_File_Input_down_box(Fl_File_Input self) -> Fl_Boxtype\n"
		"Fl_File_Input_down_box(Fl_File_Input self, Fl_Boxtype b)\n"
		""},
	 { "Fl_File_Input_errorcolor", _wrap_Fl_File_Input_errorcolor, METH_VARARGS, "\n"
		"Fl_File_Input_errorcolor(Fl_File_Input self) -> Fl_Color\n"
		"Fl_File_Input_errorcolor(Fl_File_Input self, Fl_Color c)\n"
		""},
	 { "Fl_File_Input_value", _wrap_Fl_File_Input_value, METH_VARARGS, "\n"
		"Fl_File_Input_value(Fl_File_Input self, char const * str) -> int\n"
		"Fl_File_Input_value(Fl_File_Input self, char const * str, int len) -> int\n"
		"Fl_File_Input_value(Fl_File_Input self) -> char const *\n"
		""},
	 { "Fl_File_Input_init_type", _wrap_Fl_File_Input_init_type, METH_VARARGS, "Fl_File_Input_init_type(Fl_File_Input self, char * Fl_File_Input)"},
	 { "delete_Fl_File_Input", _wrap_delete_Fl_File_Input, METH_O, "delete_Fl_File_Input(Fl_File_Input self)"},
	 { "disown_Fl_File_Input", _wrap_disown_Fl_File_Input, METH_O, NULL},
	 { "Fl_File_Input_swigregister", Fl_File_Input_swigregister, METH_O, NULL},
	 { "Fl_File_Input_swiginit", Fl_File_Input_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Fill_Dial", _wrap_new_Fl_Fill_Dial, METH_VARARGS, "new_Fl_Fill_Dial(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Fill_Dial"},
	 { "Fl_Fill_Dial_init_type", _wrap_Fl_Fill_Dial_init_type, METH_VARARGS, "Fl_Fill_Dial_init_type(Fl_Fill_Dial self, char * Fl_Fill_Dial)"},
	 { "delete_Fl_Fill_Dial", _wrap_delete_Fl_Fill_Dial, METH_O, "delete_Fl_Fill_Dial(Fl_Fill_Dial self)"},
	 { "disown_Fl_Fill_Dial", _wrap_disown_Fl_Fill_Dial, METH_O, NULL},
	 { "Fl_Fill_Dial_draw", _wrap_Fl_Fill_Dial_draw, METH_O, "Fl_Fill_Dial_draw(Fl_Fill_Dial self)"},
	 { "Fl_Fill_Dial_swigregister", Fl_Fill_Dial_swigregister, METH_O, NULL},
	 { "Fl_Fill_Dial_swiginit", Fl_Fill_Dial_swiginit, METH_VARARGS, NULL},
	 { "Fl_Slider_draw", _wrap_Fl_Slider_draw, METH_O, "Fl_Slider_draw(Fl_Slider self)"},
	 { "Fl_Slider_handle", _wrap_Fl_Slider_handle, METH_VARARGS, "Fl_Slider_handle(Fl_Slider self, int arg0) -> int"},
	 { "new_Fl_Slider", _wrap_new_Fl_Slider, METH_VARARGS, "\n"
		"Fl_Slider(int X, int Y, int W, int H, char const * L=None)\n"
		"new_Fl_Slider(PyObject * _self, uchar t, int X, int Y, int W, int H, char const * L) -> Fl_Slider\n"
		""},
	 { "Fl_Slider_scrollvalue", _wrap_Fl_Slider_scrollvalue, METH_VARARGS, "Fl_Slider_scrollvalue(Fl_Slider self, int pos, int size, int first, int total) -> int"},
	 { "Fl_Slider_bounds", _wrap_Fl_Slider_bounds, METH_VARARGS, "Fl_Slider_bounds(Fl_Slider self, double a, double b)"},
	 { "Fl_Slider_slider_size", _wrap_Fl_Slider_slider_size, METH_VARARGS, "\n"
		"Fl_Slider_slider_size(Fl_Slider self) -> float\n"
		"Fl_Slider_slider_size(Fl_Slider self, double v)\n"
		""},
	 { "Fl_Slider_slider", _wrap_Fl_Slider_slider, METH_VARARGS, "\n"
		"Fl_Slider_slider(Fl_Slider self) -> Fl_Boxtype\n"
		"Fl_Slider_slider(Fl_Slider self, Fl_Boxtype c)\n"
		""},
	 { "Fl_Slider_scale", _wrap_Fl_Slider_scale, METH_VARARGS, "\n"
		"Fl_Slider_scale(Fl_Slider self) -> Fl_Slider::Scale_Type\n"
		"Fl_Slider_scale(Fl_Slider self, Fl_Slider::Scale_Type s)\n"
		""},
	 { "Fl_Slider_num_ticks", _wrap_Fl_Slider_num_ticks, METH_O, "Fl_Slider_num_ticks(Fl_Slider self) -> uchar"},
	 { "Fl_Slider_ticks", _wrap_Fl_Slider_ticks, METH_VARARGS, "\n"
		"Fl_Slider_ticks(Fl_Slider self) -> uchar\n"
		"Fl_Slider_ticks(Fl_Slider self, uchar t, uchar num_ticks=11)\n"
		""},
	 { "Fl_Slider_init_type", _wrap_Fl_Slider_init_type, METH_VARARGS, "Fl_Slider_init_type(Fl_Slider self, char * Fl_Slider)"},
	 { "delete_Fl_Slider", _wrap_delete_Fl_Slider, METH_O, "delete_Fl_Slider(Fl_Slider self)"},
	 { "disown_Fl_Slider", _wrap_disown_Fl_Slider, METH_O, NULL},
	 { "Fl_Slider_swigregister", Fl_Slider_swigregister, METH_O, NULL},
	 { "Fl_Slider_swiginit", Fl_Slider_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Fill_Slider", _wrap_new_Fl_Fill_Slider, METH_VARARGS, "new_Fl_Fill_Slider(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Fill_Slider"},
	 { "Fl_Fill_Slider_init_type", _wrap_Fl_Fill_Slider_init_type, METH_VARARGS, "Fl_Fill_Slider_init_type(Fl_Fill_Slider self, char * Fl_Fill_Slider)"},
	 { "delete_Fl_Fill_Slider", _wrap_delete_Fl_Fill_Slider, METH_O, "delete_Fl_Fill_Slider(Fl_Fill_Slider self)"},
	 { "disown_Fl_Fill_Slider", _wrap_disown_Fl_Fill_Slider, METH_O, NULL},
	 { "Fl_Fill_Slider_draw", _wrap_Fl_Fill_Slider_draw, METH_O, "Fl_Fill_Slider_draw(Fl_Fill_Slider self)"},
	 { "Fl_Fill_Slider_swigregister", Fl_Fill_Slider_swigregister, METH_O, NULL},
	 { "Fl_Fill_Slider_swiginit", Fl_Fill_Slider_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Flex", _wrap_new_Fl_Flex, METH_VARARGS, "\n"
		"Fl_Flex(int X, int Y, int W, int H, char const * L=None)\n"
		"Fl_Flex(int direction)\n"
		"Fl_Flex(int w, int h, int direction)\n"
		"new_Fl_Flex(PyObject * _self, int x, int y, int w, int h, int direction) -> Fl_Flex\n"
		""},
	 { "delete_Fl_Flex", _wrap_delete_Fl_Flex, METH_O, "delete_Fl_Flex(Fl_Flex self)"},
	 { "Fl_Flex_end", _wrap_Fl_Flex_end, METH_O, "Fl_Flex_end(Fl_Flex self)"},
	 { "Fl_Flex_resize", _wrap_Fl_Flex_resize, METH_VARARGS, "Fl_Flex_resize(Fl_Flex self, int x, int y, int w, int h)"},
	 { "Fl_Flex_fixed", _wrap_Fl_Flex_fixed, METH_VARARGS, "\n"
		"Fl_Flex_fixed(Fl_Flex self, Fl_Widget w, int size)\n"
		"Fl_Flex_fixed(Fl_Flex self, Fl_Widget w, int size)\n"
		"Fl_Flex_fixed(Fl_Flex self, Fl_Widget w) -> int\n"
		""},
	 { "Fl_Flex_alloc_size", _wrap_Fl_Flex_alloc_size, METH_VARARGS, "Fl_Flex_alloc_size(Fl_Flex self, int size) -> int"},
	 { "Fl_Flex_draw", _wrap_Fl_Flex_draw, METH_O, "Fl_Flex_draw(Fl_Flex self)"},
	 { "Fl_Flex_need_layout", _wrap_Fl_Flex_need_layout, METH_VARARGS, "\n"
		"Fl_Flex_need_layout(Fl_Flex self, int set)\n"
		"Fl_Flex_need_layout(Fl_Flex self) -> bool\n"
		""},
	 { "Fl_Flex_margin", _wrap_Fl_Flex_margin, METH_VARARGS, "\n"
		"Fl_Flex_margin(Fl_Flex self) -> int\n"
		"Fl_Flex_margin(Fl_Flex self, int * left, int * top, int * right, int * bottom) -> int\n"
		"Fl_Flex_margin(Fl_Flex self, int m, int g=-1)\n"
		"Fl_Flex_margin(Fl_Flex self, int left, int top, int right, int bottom)\n"
		""},
	 { "Fl_Flex_gap", _wrap_Fl_Flex_gap, METH_VARARGS, "\n"
		"Fl_Flex_gap(Fl_Flex self) -> int\n"
		"Fl_Flex_gap(Fl_Flex self, int g)\n"
		""},
	 { "Fl_Flex_horizontal", _wrap_Fl_Flex_horizontal, METH_O, "Fl_Flex_horizontal(Fl_Flex self) -> int"},
	 { "Fl_Flex_layout", _wrap_Fl_Flex_layout, METH_O, "Fl_Flex_layout(Fl_Flex self)"},
	 { "Fl_Flex_spacing", _wrap_Fl_Flex_spacing, METH_VARARGS, "\n"
		"Fl_Flex_spacing(Fl_Flex self) -> int\n"
		"Fl_Flex_spacing(Fl_Flex self, int i)\n"
		""},
	 { "Fl_Flex_init_type", _wrap_Fl_Flex_init_type, METH_VARARGS, "Fl_Flex_init_type(Fl_Flex self, char * Fl_Flex)"},
	 { "disown_Fl_Flex", _wrap_disown_Fl_Flex, METH_O, NULL},
	 { "Fl_Flex_swigregister", Fl_Flex_swigregister, METH_O, NULL},
	 { "Fl_Flex_swiginit", Fl_Flex_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Float_Input", _wrap_new_Fl_Float_Input, METH_VARARGS, "new_Fl_Float_Input(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Float_Input"},
	 { "Fl_Float_Input_init_type", _wrap_Fl_Float_Input_init_type, METH_VARARGS, "Fl_Float_Input_init_type(Fl_Float_Input self, char * Fl_Float_Input)"},
	 { "delete_Fl_Float_Input", _wrap_delete_Fl_Float_Input, METH_O, "delete_Fl_Float_Input(Fl_Float_Input self)"},
	 { "disown_Fl_Float_Input", _wrap_disown_Fl_Float_Input, METH_O, NULL},
	 { "Fl_Float_Input_draw", _wrap_Fl_Float_Input_draw, METH_O, "Fl_Float_Input_draw(Fl_Float_Input self)"},
	 { "Fl_Float_Input_swigregister", Fl_Float_Input_swigregister, METH_O, NULL},
	 { "Fl_Float_Input_swiginit", Fl_Float_Input_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Pixmap", _wrap_new_Fl_Pixmap, METH_VARARGS, "new_Fl_Pixmap(PyObject * _self, char const *const * D) -> Fl_Pixmap"},
	 { "delete_Fl_Pixmap", _wrap_delete_Fl_Pixmap, METH_O, "delete_Fl_Pixmap(Fl_Pixmap self)"},
	 { "Fl_Pixmap_copy", _wrap_Fl_Pixmap_copy, METH_VARARGS, "\n"
		"Fl_Pixmap_copy(Fl_Pixmap self, int W, int H) -> Fl_Image\n"
		"Fl_Pixmap_copy(Fl_Pixmap self) -> Fl_Image\n"
		""},
	 { "Fl_Pixmap_color_average", _wrap_Fl_Pixmap_color_average, METH_VARARGS, "Fl_Pixmap_color_average(Fl_Pixmap self, Fl_Color c, float i)"},
	 { "Fl_Pixmap_desaturate", _wrap_Fl_Pixmap_desaturate, METH_O, "Fl_Pixmap_desaturate(Fl_Pixmap self)"},
	 { "Fl_Pixmap_draw", _wrap_Fl_Pixmap_draw, METH_VARARGS, "\n"
		"Fl_Pixmap_draw(Fl_Pixmap self, int X, int Y, int W, int H, int cx=0, int cy=0)\n"
		"Fl_Pixmap_draw(Fl_Pixmap self, int X, int Y)\n"
		""},
	 { "Fl_Pixmap_label", _wrap_Fl_Pixmap_label, METH_VARARGS, "\n"
		"Fl_Pixmap_label(Fl_Pixmap self, Fl_Widget w)\n"
		"Fl_Pixmap_label(Fl_Pixmap self, Fl_Menu_Item m)\n"
		""},
	 { "Fl_Pixmap_uncache", _wrap_Fl_Pixmap_uncache, METH_O, "Fl_Pixmap_uncache(Fl_Pixmap self)"},
	 { "Fl_Pixmap_cache_w", _wrap_Fl_Pixmap_cache_w, METH_O, "Fl_Pixmap_cache_w(Fl_Pixmap self) -> int"},
	 { "Fl_Pixmap_cache_h", _wrap_Fl_Pixmap_cache_h, METH_O, "Fl_Pixmap_cache_h(Fl_Pixmap self) -> int"},
	 { "disown_Fl_Pixmap", _wrap_disown_Fl_Pixmap, METH_O, NULL},
	 { "Fl_Pixmap_swigregister", Fl_Pixmap_swigregister, METH_O, NULL},
	 { "Fl_Pixmap_swiginit", Fl_Pixmap_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Grid", _wrap_new_Fl_Grid, METH_VARARGS, "new_Fl_Grid(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Grid"},
	 { "delete_Fl_Grid", _wrap_delete_Fl_Grid, METH_O, "delete_Fl_Grid(Fl_Grid self)"},
	 { "Fl_Grid_layout", _wrap_Fl_Grid_layout, METH_VARARGS, "\n"
		"Fl_Grid_layout(Fl_Grid self, int rows, int cols, int margin=-1, int gap=-1)\n"
		"Fl_Grid_layout(Fl_Grid self)\n"
		""},
	 { "Fl_Grid_clear_layout", _wrap_Fl_Grid_clear_layout, METH_O, "Fl_Grid_clear_layout(Fl_Grid self)"},
	 { "Fl_Grid_resize", _wrap_Fl_Grid_resize, METH_VARARGS, "Fl_Grid_resize(Fl_Grid self, int X, int Y, int W, int H)"},
	 { "Fl_Grid_rows", _wrap_Fl_Grid_rows, METH_O, "Fl_Grid_rows(Fl_Grid self) -> short"},
	 { "Fl_Grid_cols", _wrap_Fl_Grid_cols, METH_O, "Fl_Grid_cols(Fl_Grid self) -> short"},
	 { "Fl_Grid_need_layout", _wrap_Fl_Grid_need_layout, METH_VARARGS, "\n"
		"Fl_Grid_need_layout(Fl_Grid self, int set)\n"
		"Fl_Grid_need_layout(Fl_Grid self) -> bool\n"
		""},
	 { "Fl_Grid_draw", _wrap_Fl_Grid_draw, METH_O, "Fl_Grid_draw(Fl_Grid self)"},
	 { "Fl_Grid_draw_grid", _wrap_Fl_Grid_draw_grid, METH_O, "Fl_Grid_draw_grid(Fl_Grid self)"},
	 { "Fl_Grid_margin", _wrap_Fl_Grid_margin, METH_VARARGS, "\n"
		"Fl_Grid_margin(Fl_Grid self, int left, int top=-1, int right=-1, int bottom=-1)\n"
		"Fl_Grid_margin(Fl_Grid self, int * left, int * top, int * right, int * bottom) -> int\n"
		""},
	 { "Fl_Grid_gap", _wrap_Fl_Grid_gap, METH_VARARGS, "\n"
		"Fl_Grid_gap(Fl_Grid self, int row_gap, int col_gap=-1)\n"
		"Fl_Grid_gap(Fl_Grid self, int * row_gap, int * col_gap)\n"
		""},
	 { "Fl_Grid_cell", _wrap_Fl_Grid_cell, METH_VARARGS, "\n"
		"Fl_Grid_cell(Fl_Grid self, int row, int col) -> Fl_Grid::Cell\n"
		"Fl_Grid_cell(Fl_Grid self, Fl_Widget widget) -> Fl_Grid::Cell *\n"
		""},
	 { "Fl_Grid_widget", _wrap_Fl_Grid_widget, METH_VARARGS, "\n"
		"Fl_Grid_widget(Fl_Grid self, Fl_Widget wi, int row, int col, Fl_Grid_Align align=) -> Fl_Grid::Cell\n"
		"Fl_Grid_widget(Fl_Grid self, Fl_Widget wi, int row, int col, int rowspan, int colspan, Fl_Grid_Align align=) -> Fl_Grid::Cell *\n"
		""},
	 { "Fl_Grid_col_width", _wrap_Fl_Grid_col_width, METH_VARARGS, "\n"
		"Fl_Grid_col_width(Fl_Grid self, int col, int value)\n"
		"Fl_Grid_col_width(Fl_Grid self, int const * value)\n"
		"Fl_Grid_col_width(Fl_Grid self, int col) -> int\n"
		""},
	 { "Fl_Grid_col_weight", _wrap_Fl_Grid_col_weight, METH_VARARGS, "\n"
		"Fl_Grid_col_weight(Fl_Grid self, int col, int value)\n"
		"Fl_Grid_col_weight(Fl_Grid self, int const * value)\n"
		"Fl_Grid_col_weight(Fl_Grid self, int col) -> int\n"
		""},
	 { "Fl_Grid_col_gap", _wrap_Fl_Grid_col_gap, METH_VARARGS, "\n"
		"Fl_Grid_col_gap(Fl_Grid self, int col, int value)\n"
		"Fl_Grid_col_gap(Fl_Grid self, int const * value)\n"
		"Fl_Grid_col_gap(Fl_Grid self, int col) -> int\n"
		""},
	 { "Fl_Grid_row_height", _wrap_Fl_Grid_row_height, METH_VARARGS, "\n"
		"Fl_Grid_row_height(Fl_Grid self, int row, int value)\n"
		"Fl_Grid_row_height(Fl_Grid self, int const * value)\n"
		"Fl_Grid_row_height(Fl_Grid self, int row) -> int\n"
		""},
	 { "Fl_Grid_row_weight", _wrap_Fl_Grid_row_weight, METH_VARARGS, "\n"
		"Fl_Grid_row_weight(Fl_Grid self, int row, int value)\n"
		"Fl_Grid_row_weight(Fl_Grid self, int const * value)\n"
		"Fl_Grid_row_weight(Fl_Grid self, int row) -> int\n"
		""},
	 { "Fl_Grid_row_gap", _wrap_Fl_Grid_row_gap, METH_VARARGS, "\n"
		"Fl_Grid_row_gap(Fl_Grid self, int row, int value)\n"
		"Fl_Grid_row_gap(Fl_Grid self, int const * value)\n"
		"Fl_Grid_row_gap(Fl_Grid self, int row) -> int\n"
		""},
	 { "Fl_Grid_computed_col_width", _wrap_Fl_Grid_computed_col_width, METH_VARARGS, "Fl_Grid_computed_col_width(Fl_Grid self, int col) -> int"},
	 { "Fl_Grid_computed_row_height", _wrap_Fl_Grid_computed_row_height, METH_VARARGS, "Fl_Grid_computed_row_height(Fl_Grid self, int row) -> int"},
	 { "Fl_Grid_show_grid", _wrap_Fl_Grid_show_grid, METH_VARARGS, "\n"
		"Fl_Grid_show_grid(Fl_Grid self, int set)\n"
		"Fl_Grid_show_grid(Fl_Grid self, int set, Fl_Color col)\n"
		""},
	 { "Fl_Grid_debug", _wrap_Fl_Grid_debug, METH_VARARGS, "Fl_Grid_debug(Fl_Grid self, int level=127)"},
	 { "Fl_Grid_init_type", _wrap_Fl_Grid_init_type, METH_VARARGS, "Fl_Grid_init_type(Fl_Grid self, char * Fl_Grid)"},
	 { "disown_Fl_Grid", _wrap_disown_Fl_Grid, METH_O, NULL},
	 { "Fl_Grid_swigregister", Fl_Grid_swigregister, METH_O, NULL},
	 { "Fl_Grid_swiginit", Fl_Grid_swiginit, METH_VARARGS, NULL},
	 { "Fl_GIF_Image_is_animated", _wrap_Fl_GIF_Image_is_animated, METH_O, "Fl_GIF_Image_is_animated(char const * name_) -> bool"},
	 { "new_Fl_GIF_Image", _wrap_new_Fl_GIF_Image, METH_VARARGS, "\n"
		"Fl_GIF_Image(char const * filename)\n"
		"Fl_GIF_Image(char const * imagename, unsigned char const * data)\n"
		"Fl_GIF_Image(char const * imagename, unsigned char const * data, size_t const length)\n"
		"Fl_GIF_Image(char const * filename, bool anim)\n"
		"Fl_GIF_Image(char const * imagename, unsigned char const * data, size_t const length, bool anim)\n"
		"new_Fl_GIF_Image(PyObject * _self) -> Fl_GIF_Image\n"
		""},
	 { "delete_Fl_GIF_Image", _wrap_delete_Fl_GIF_Image, METH_O, "delete_Fl_GIF_Image(Fl_GIF_Image self)"},
	 { "disown_Fl_GIF_Image", _wrap_disown_Fl_GIF_Image, METH_O, NULL},
	 { "Fl_GIF_Image_swigregister", Fl_GIF_Image_swigregister, METH_O, NULL},
	 { "Fl_GIF_Image_swiginit", Fl_GIF_Image_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Anim_GIF_Image", _wrap_new_Fl_Anim_GIF_Image, METH_VARARGS, "\n"
		"Fl_Anim_GIF_Image(char const * filename, Fl_Widget canvas=None, unsigned short flags=0)\n"
		"Fl_Anim_GIF_Image(char const * imagename, unsigned char const * data, size_t const length, Fl_Widget canvas=None, unsigned short flags=0)\n"
		"new_Fl_Anim_GIF_Image(PyObject * _self) -> Fl_Anim_GIF_Image\n"
		""},
	 { "delete_Fl_Anim_GIF_Image", _wrap_delete_Fl_Anim_GIF_Image, METH_O, "delete_Fl_Anim_GIF_Image(Fl_Anim_GIF_Image self)"},
	 { "Fl_Anim_GIF_Image_load", _wrap_Fl_Anim_GIF_Image_load, METH_VARARGS, "Fl_Anim_GIF_Image_load(Fl_Anim_GIF_Image self, char const * name, unsigned char const * imgdata=None, size_t imglength=0) -> bool"},
	 { "Fl_Anim_GIF_Image_valid", _wrap_Fl_Anim_GIF_Image_valid, METH_O, "Fl_Anim_GIF_Image_valid(Fl_Anim_GIF_Image self) -> bool"},
	 { "Fl_Anim_GIF_Image_frame_uncache", _wrap_Fl_Anim_GIF_Image_frame_uncache, METH_VARARGS, "\n"
		"Fl_Anim_GIF_Image_frame_uncache(Fl_Anim_GIF_Image self, bool uncache)\n"
		"Fl_Anim_GIF_Image_frame_uncache(Fl_Anim_GIF_Image self) -> bool\n"
		""},
	 { "Fl_Anim_GIF_Image_delay", _wrap_Fl_Anim_GIF_Image_delay, METH_VARARGS, "\n"
		"Fl_Anim_GIF_Image_delay(Fl_Anim_GIF_Image self, int frame_) -> double\n"
		"Fl_Anim_GIF_Image_delay(Fl_Anim_GIF_Image self, int frame, double delay)\n"
		""},
	 { "Fl_Anim_GIF_Image_canvas", _wrap_Fl_Anim_GIF_Image_canvas, METH_VARARGS, "\n"
		"Fl_Anim_GIF_Image_canvas(Fl_Anim_GIF_Image self, Fl_Widget canvas, unsigned short flags=0)\n"
		"Fl_Anim_GIF_Image_canvas(Fl_Anim_GIF_Image self) -> Fl_Widget\n"
		""},
	 { "Fl_Anim_GIF_Image_canvas_w", _wrap_Fl_Anim_GIF_Image_canvas_w, METH_O, "Fl_Anim_GIF_Image_canvas_w(Fl_Anim_GIF_Image self) -> int"},
	 { "Fl_Anim_GIF_Image_canvas_h", _wrap_Fl_Anim_GIF_Image_canvas_h, METH_O, "Fl_Anim_GIF_Image_canvas_h(Fl_Anim_GIF_Image self) -> int"},
	 { "Fl_Anim_GIF_Image_is_animated", _wrap_Fl_Anim_GIF_Image_is_animated, METH_O, "Fl_Anim_GIF_Image_is_animated(Fl_Anim_GIF_Image self) -> bool"},
	 { "Fl_Anim_GIF_Image_name", _wrap_Fl_Anim_GIF_Image_name, METH_O, "Fl_Anim_GIF_Image_name(Fl_Anim_GIF_Image self) -> char const *"},
	 { "Fl_Anim_GIF_Image_speed", _wrap_Fl_Anim_GIF_Image_speed, METH_VARARGS, "\n"
		"Fl_Anim_GIF_Image_speed(Fl_Anim_GIF_Image self, double speed)\n"
		"Fl_Anim_GIF_Image_speed(Fl_Anim_GIF_Image self) -> double\n"
		""},
	 { "Fl_Anim_GIF_Image_frames", _wrap_Fl_Anim_GIF_Image_frames, METH_O, "Fl_Anim_GIF_Image_frames(Fl_Anim_GIF_Image self) -> int"},
	 { "Fl_Anim_GIF_Image_frame", _wrap_Fl_Anim_GIF_Image_frame, METH_VARARGS, "\n"
		"Fl_Anim_GIF_Image_frame(Fl_Anim_GIF_Image self, int frame)\n"
		"Fl_Anim_GIF_Image_frame(Fl_Anim_GIF_Image self) -> int\n"
		""},
	 { "Fl_Anim_GIF_Image_image", _wrap_Fl_Anim_GIF_Image_image, METH_VARARGS, "\n"
		"Fl_Anim_GIF_Image_image(Fl_Anim_GIF_Image self) -> Fl_Image\n"
		"Fl_Anim_GIF_Image_image(Fl_Anim_GIF_Image self, int frame) -> Fl_Image\n"
		""},
	 { "Fl_Anim_GIF_Image_start", _wrap_Fl_Anim_GIF_Image_start, METH_O, "Fl_Anim_GIF_Image_start(Fl_Anim_GIF_Image self) -> bool"},
	 { "Fl_Anim_GIF_Image_stop", _wrap_Fl_Anim_GIF_Image_stop, METH_O, "Fl_Anim_GIF_Image_stop(Fl_Anim_GIF_Image self) -> bool"},
	 { "Fl_Anim_GIF_Image_next", _wrap_Fl_Anim_GIF_Image_next, METH_O, "Fl_Anim_GIF_Image_next(Fl_Anim_GIF_Image self) -> bool"},
	 { "Fl_Anim_GIF_Image_playing", _wrap_Fl_Anim_GIF_Image_playing, METH_O, "Fl_Anim_GIF_Image_playing(Fl_Anim_GIF_Image self) -> bool"},
	 { "Fl_Anim_GIF_Image_resize", _wrap_Fl_Anim_GIF_Image_resize, METH_VARARGS, "\n"
		"Fl_Anim_GIF_Image_resize(Fl_Anim_GIF_Image self, int w, int h) -> Fl_Anim_GIF_Image\n"
		"Fl_Anim_GIF_Image_resize(Fl_Anim_GIF_Image self, double scale) -> Fl_Anim_GIF_Image\n"
		""},
	 { "Fl_Anim_GIF_Image_frame_x", _wrap_Fl_Anim_GIF_Image_frame_x, METH_VARARGS, "Fl_Anim_GIF_Image_frame_x(Fl_Anim_GIF_Image self, int frame) -> int"},
	 { "Fl_Anim_GIF_Image_frame_y", _wrap_Fl_Anim_GIF_Image_frame_y, METH_VARARGS, "Fl_Anim_GIF_Image_frame_y(Fl_Anim_GIF_Image self, int frame) -> int"},
	 { "Fl_Anim_GIF_Image_frame_w", _wrap_Fl_Anim_GIF_Image_frame_w, METH_VARARGS, "Fl_Anim_GIF_Image_frame_w(Fl_Anim_GIF_Image self, int frame) -> int"},
	 { "Fl_Anim_GIF_Image_frame_h", _wrap_Fl_Anim_GIF_Image_frame_h, METH_VARARGS, "Fl_Anim_GIF_Image_frame_h(Fl_Anim_GIF_Image self, int frame) -> int"},
	 { "Fl_Anim_GIF_Image_color_average", _wrap_Fl_Anim_GIF_Image_color_average, METH_VARARGS, "Fl_Anim_GIF_Image_color_average(Fl_Anim_GIF_Image self, Fl_Color c, float i)"},
	 { "Fl_Anim_GIF_Image_copy", _wrap_Fl_Anim_GIF_Image_copy, METH_VARARGS, "\n"
		"Fl_Anim_GIF_Image_copy(Fl_Anim_GIF_Image self, int W, int H) -> Fl_Image\n"
		"Fl_Anim_GIF_Image_copy(Fl_Anim_GIF_Image self) -> Fl_Image\n"
		""},
	 { "Fl_Anim_GIF_Image_desaturate", _wrap_Fl_Anim_GIF_Image_desaturate, METH_O, "Fl_Anim_GIF_Image_desaturate(Fl_Anim_GIF_Image self)"},
	 { "Fl_Anim_GIF_Image_draw", _wrap_Fl_Anim_GIF_Image_draw, METH_VARARGS, "Fl_Anim_GIF_Image_draw(Fl_Anim_GIF_Image self, int x, int y, int w, int h, int cx=0, int cy=0)"},
	 { "Fl_Anim_GIF_Image_uncache", _wrap_Fl_Anim_GIF_Image_uncache, METH_O, "Fl_Anim_GIF_Image_uncache(Fl_Anim_GIF_Image self)"},
	 { "Fl_Anim_GIF_Image_debug", _wrap_Fl_Anim_GIF_Image_debug, METH_O, "Fl_Anim_GIF_Image_debug(Fl_Anim_GIF_Image self) -> int"},
	 { "Fl_Anim_GIF_Image_frame_count", _wrap_Fl_Anim_GIF_Image_frame_count, METH_VARARGS, "Fl_Anim_GIF_Image_frame_count(char const * name, unsigned char const * imgdata=None, size_t imglength=0) -> int"},
	 { "disown_Fl_Anim_GIF_Image", _wrap_disown_Fl_Anim_GIF_Image, METH_O, NULL},
	 { "Fl_Anim_GIF_Image_swigregister", Fl_Anim_GIF_Image_swigregister, METH_O, NULL},
	 { "Fl_Anim_GIF_Image_swiginit", Fl_Anim_GIF_Image_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_ICO_Image", _wrap_new_Fl_ICO_Image, METH_VARARGS, "new_Fl_ICO_Image(PyObject * _self, char const * filename, int id=-1, unsigned char const * data=None, size_t const datasize=0) -> Fl_ICO_Image"},
	 { "delete_Fl_ICO_Image", _wrap_delete_Fl_ICO_Image, METH_O, "delete_Fl_ICO_Image(Fl_ICO_Image self)"},
	 { "Fl_ICO_Image_idcount", _wrap_Fl_ICO_Image_idcount, METH_O, "Fl_ICO_Image_idcount(Fl_ICO_Image self) -> int"},
	 { "Fl_ICO_Image_icondirentry", _wrap_Fl_ICO_Image_icondirentry, METH_O, "Fl_ICO_Image_icondirentry(Fl_ICO_Image self) -> Fl_ICO_Image::IconDirEntry const *"},
	 { "disown_Fl_ICO_Image", _wrap_disown_Fl_ICO_Image, METH_O, NULL},
	 { "Fl_ICO_Image_swigregister", Fl_ICO_Image_swigregister, METH_O, NULL},
	 { "Fl_ICO_Image_swiginit", Fl_ICO_Image_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Image_Surface", _wrap_new_Fl_Image_Surface, METH_VARARGS, "new_Fl_Image_Surface(int w, int h, int high_res=0, Fl_Offscreen off=0) -> Fl_Image_Surface"},
	 { "delete_Fl_Image_Surface", _wrap_delete_Fl_Image_Surface, METH_O, "delete_Fl_Image_Surface(Fl_Image_Surface self)"},
	 { "Fl_Image_Surface_set_current", _wrap_Fl_Image_Surface_set_current, METH_O, "Fl_Image_Surface_set_current(Fl_Image_Surface self)"},
	 { "Fl_Image_Surface_is_current", _wrap_Fl_Image_Surface_is_current, METH_O, "Fl_Image_Surface_is_current(Fl_Image_Surface self) -> bool"},
	 { "Fl_Image_Surface_image", _wrap_Fl_Image_Surface_image, METH_O, "Fl_Image_Surface_image(Fl_Image_Surface self) -> Fl_RGB_Image"},
	 { "Fl_Image_Surface_highres_image", _wrap_Fl_Image_Surface_highres_image, METH_O, "Fl_Image_Surface_highres_image(Fl_Image_Surface self) -> Fl_Shared_Image"},
	 { "Fl_Image_Surface_origin", _wrap_Fl_Image_Surface_origin, METH_VARARGS, "\n"
		"Fl_Image_Surface_origin(Fl_Image_Surface self, int * x, int * y)\n"
		"Fl_Image_Surface_origin(Fl_Image_Surface self, int x, int y)\n"
		""},
	 { "Fl_Image_Surface_printable_rect", _wrap_Fl_Image_Surface_printable_rect, METH_VARARGS, "Fl_Image_Surface_printable_rect(Fl_Image_Surface self, int * w, int * h) -> int"},
	 { "Fl_Image_Surface_offscreen", _wrap_Fl_Image_Surface_offscreen, METH_O, "Fl_Image_Surface_offscreen(Fl_Image_Surface self) -> Fl_Offscreen"},
	 { "Fl_Image_Surface_rescale", _wrap_Fl_Image_Surface_rescale, METH_O, "Fl_Image_Surface_rescale(Fl_Image_Surface self)"},
	 { "Fl_Image_Surface_mask", _wrap_Fl_Image_Surface_mask, METH_VARARGS, "Fl_Image_Surface_mask(Fl_Image_Surface self, Fl_RGB_Image arg2)"},
	 { "Fl_Image_Surface_swigregister", Fl_Image_Surface_swigregister, METH_O, NULL},
	 { "Fl_Image_Surface_swiginit", Fl_Image_Surface_swiginit, METH_VARARGS, NULL},
	 { "fl_strdup", _wrap_fl_strdup, METH_O, "fl_strdup(char const * s) -> char *"},
	 { "fl_strlcpy", _wrap_fl_strlcpy, METH_VARARGS, "fl_strlcpy(char * arg1, char const * arg2, size_t arg3) -> size_t"},
	 { "Fl_Gl_Window_draw", _wrap_Fl_Gl_Window_draw, METH_O, "Fl_Gl_Window_draw(Fl_Gl_Window self)"},
	 { "Fl_Gl_Window_flush", _wrap_Fl_Gl_Window_flush, METH_O, "Fl_Gl_Window_flush(Fl_Gl_Window self)"},
	 { "Fl_Gl_Window_hide", _wrap_Fl_Gl_Window_hide, METH_O, "Fl_Gl_Window_hide(Fl_Gl_Window self)"},
	 { "Fl_Gl_Window_resize", _wrap_Fl_Gl_Window_resize, METH_VARARGS, "Fl_Gl_Window_resize(Fl_Gl_Window self, int arg0, int arg1, int arg2, int arg3)"},
	 { "Fl_Gl_Window_handle", _wrap_Fl_Gl_Window_handle, METH_VARARGS, "Fl_Gl_Window_handle(Fl_Gl_Window self, int arg0) -> int"},
	 { "Fl_Gl_Window_valid", _wrap_Fl_Gl_Window_valid, METH_VARARGS, "\n"
		"Fl_Gl_Window_valid(Fl_Gl_Window self) -> char\n"
		"Fl_Gl_Window_valid(Fl_Gl_Window self, char v)\n"
		""},
	 { "Fl_Gl_Window_invalidate", _wrap_Fl_Gl_Window_invalidate, METH_O, "Fl_Gl_Window_invalidate(Fl_Gl_Window self)"},
	 { "Fl_Gl_Window_context_valid", _wrap_Fl_Gl_Window_context_valid, METH_VARARGS, "\n"
		"Fl_Gl_Window_context_valid(Fl_Gl_Window self) -> char\n"
		"Fl_Gl_Window_context_valid(Fl_Gl_Window self, char v)\n"
		""},
	 { "Fl_Gl_Window_can_do", _wrap_Fl_Gl_Window_can_do, METH_VARARGS, "\n"
		"Fl_Gl_Window_can_do(Fl_Gl_Window self, int m) -> int\n"
		"Fl_Gl_Window_can_do(Fl_Gl_Window self, int const * m) -> int\n"
		"Fl_Gl_Window_can_do(Fl_Gl_Window self) -> int\n"
		""},
	 { "Fl_Gl_Window_mode", _wrap_Fl_Gl_Window_mode, METH_VARARGS, "\n"
		"Fl_Gl_Window_mode(Fl_Gl_Window self) -> Fl_Mode\n"
		"Fl_Gl_Window_mode(Fl_Gl_Window self, int a) -> int\n"
		"Fl_Gl_Window_mode(Fl_Gl_Window self, int const * a) -> int\n"
		""},
	 { "Fl_Gl_Window_context", _wrap_Fl_Gl_Window_context, METH_VARARGS, "\n"
		"Fl_Gl_Window_context(Fl_Gl_Window self) -> GLContext\n"
		"Fl_Gl_Window_context(Fl_Gl_Window self, GLContext arg2, int destroy_flag=0)\n"
		""},
	 { "Fl_Gl_Window_make_current", _wrap_Fl_Gl_Window_make_current, METH_O, "Fl_Gl_Window_make_current(Fl_Gl_Window self)"},
	 { "Fl_Gl_Window_swap_buffers", _wrap_Fl_Gl_Window_swap_buffers, METH_O, "Fl_Gl_Window_swap_buffers(Fl_Gl_Window self)"},
	 { "Fl_Gl_Window_swap_interval", _wrap_Fl_Gl_Window_swap_interval, METH_VARARGS, "\n"
		"Fl_Gl_Window_swap_interval(Fl_Gl_Window self, int arg2)\n"
		"Fl_Gl_Window_swap_interval(Fl_Gl_Window self) -> int\n"
		""},
	 { "Fl_Gl_Window_ortho", _wrap_Fl_Gl_Window_ortho, METH_O, "Fl_Gl_Window_ortho(Fl_Gl_Window self)"},
	 { "Fl_Gl_Window_can_do_overlay", _wrap_Fl_Gl_Window_can_do_overlay, METH_O, "Fl_Gl_Window_can_do_overlay(Fl_Gl_Window self) -> int"},
	 { "Fl_Gl_Window_redraw_overlay", _wrap_Fl_Gl_Window_redraw_overlay, METH_O, "Fl_Gl_Window_redraw_overlay(Fl_Gl_Window self)"},
	 { "Fl_Gl_Window_hide_overlay", _wrap_Fl_Gl_Window_hide_overlay, METH_O, "Fl_Gl_Window_hide_overlay(Fl_Gl_Window self)"},
	 { "Fl_Gl_Window_make_overlay_current", _wrap_Fl_Gl_Window_make_overlay_current, METH_O, "Fl_Gl_Window_make_overlay_current(Fl_Gl_Window self)"},
	 { "Fl_Gl_Window_as_gl_window", _wrap_Fl_Gl_Window_as_gl_window, METH_VARARGS, "\n"
		"Fl_Gl_Window_as_gl_window(Fl_Gl_Window self) -> Fl_Gl_Window\n"
		"Fl_Gl_Window_as_gl_window(Fl_Gl_Window self) -> Fl_Gl_Window\n"
		""},
	 { "Fl_Gl_Window_pixels_per_unit", _wrap_Fl_Gl_Window_pixels_per_unit, METH_O, "Fl_Gl_Window_pixels_per_unit(Fl_Gl_Window self) -> float"},
	 { "Fl_Gl_Window_pixel_w", _wrap_Fl_Gl_Window_pixel_w, METH_O, "Fl_Gl_Window_pixel_w(Fl_Gl_Window self) -> int"},
	 { "Fl_Gl_Window_pixel_h", _wrap_Fl_Gl_Window_pixel_h, METH_O, "Fl_Gl_Window_pixel_h(Fl_Gl_Window self) -> int"},
	 { "delete_Fl_Gl_Window", _wrap_delete_Fl_Gl_Window, METH_O, "delete_Fl_Gl_Window(Fl_Gl_Window self)"},
	 { "new_Fl_Gl_Window", _wrap_new_Fl_Gl_Window, METH_VARARGS, "\n"
		"Fl_Gl_Window(int W, int H, char const * l=None)\n"
		"new_Fl_Gl_Window(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Gl_Window\n"
		""},
	 { "Fl_Gl_Window_init_type", _wrap_Fl_Gl_Window_init_type, METH_VARARGS, "Fl_Gl_Window_init_type(Fl_Gl_Window self, char * Fl_Gl_Window)"},
	 { "Fl_Gl_Window_show", _wrap_Fl_Gl_Window_show, METH_VARARGS, "Fl_Gl_Window_show(Fl_Gl_Window self, PyObject * count=None, PyObject * data=None)"},
	 { "Fl_Gl_Window_drawPixels", _wrap_Fl_Gl_Window_drawPixels, METH_VARARGS, "\n"
		"Fl_Gl_Window_drawPixels(Fl_Gl_Window self, PyObject * rgb_py)\n"
		"Writes a raw RGB string to the canvas.\n"
		"\n"
		"Arguments:\n"
		"    - rgb - a string of width * height * 3 bytes, comprising\n"
		"      the raw image in RGB format\n"
		"\n"
		""},
	 { "disown_Fl_Gl_Window", _wrap_disown_Fl_Gl_Window, METH_O, NULL},
	 { "Fl_Gl_Window_swigregister", Fl_Gl_Window_swigregister, METH_O, NULL},
	 { "Fl_Gl_Window_swiginit", Fl_Gl_Window_swiginit, METH_VARARGS, NULL},
	 { "gl_start", _wrap_gl_start, METH_NOARGS, "gl_start()"},
	 { "gl_finish", _wrap_gl_finish, METH_NOARGS, "gl_finish()"},
	 { "gl_color", _wrap_gl_color, METH_VARARGS, "\n"
		"gl_color(Fl_Color i)\n"
		"gl_color(int c)\n"
		""},
	 { "gl_rect", _wrap_gl_rect, METH_VARARGS, "gl_rect(int x, int y, int w, int h)"},
	 { "gl_rectf", _wrap_gl_rectf, METH_VARARGS, "gl_rectf(int x, int y, int w, int h)"},
	 { "gl_font", _wrap_gl_font, METH_VARARGS, "gl_font(int fontid, int size)"},
	 { "gl_height", _wrap_gl_height, METH_NOARGS, "gl_height() -> int"},
	 { "gl_descent", _wrap_gl_descent, METH_NOARGS, "gl_descent() -> int"},
	 { "gl_width", _wrap_gl_width, METH_VARARGS, "\n"
		"gl_width(char const * arg1) -> double\n"
		"gl_width(char const * arg1, int n) -> double\n"
		"gl_width(uchar arg1) -> double\n"
		""},
	 { "gl_draw", _wrap_gl_draw, METH_VARARGS, "\n"
		"gl_draw(char const * arg1)\n"
		"gl_draw(char const * arg1, int n)\n"
		"gl_draw(char const * arg1, int x, int y)\n"
		"gl_draw(char const * arg1, float x, float y)\n"
		"gl_draw(char const * arg1, int n, int x, int y)\n"
		"gl_draw(char const * arg1, int n, float x, float y)\n"
		"gl_draw(char const * arg1, int x, int y, int w, int h, Fl_Align arg6)\n"
		""},
	 { "gl_measure", _wrap_gl_measure, METH_O, "gl_measure(char const * arg1)"},
	 { "gl_texture_pile_height", _wrap_gl_texture_pile_height, METH_VARARGS, "\n"
		"gl_texture_pile_height(int max)\n"
		"gl_texture_pile_height() -> int\n"
		""},
	 { "gl_texture_reset", _wrap_gl_texture_reset, METH_NOARGS, "gl_texture_reset()"},
	 { "gl_draw_image", _wrap_gl_draw_image, METH_VARARGS, "gl_draw_image(uchar const * arg1, int x, int y, int w, int h, int d=3, int ld=0)"},
	 { "new_Fl_Help_Dialog", _wrap_new_Fl_Help_Dialog, METH_NOARGS, "new_Fl_Help_Dialog() -> Fl_Help_Dialog"},
	 { "delete_Fl_Help_Dialog", _wrap_delete_Fl_Help_Dialog, METH_O, "delete_Fl_Help_Dialog(Fl_Help_Dialog self)"},
	 { "Fl_Help_Dialog_h", _wrap_Fl_Help_Dialog_h, METH_O, "Fl_Help_Dialog_h(Fl_Help_Dialog self) -> int"},
	 { "Fl_Help_Dialog_hide", _wrap_Fl_Help_Dialog_hide, METH_O, "Fl_Help_Dialog_hide(Fl_Help_Dialog self)"},
	 { "Fl_Help_Dialog_load", _wrap_Fl_Help_Dialog_load, METH_VARARGS, "Fl_Help_Dialog_load(Fl_Help_Dialog self, char const * f) -> int"},
	 { "Fl_Help_Dialog_position", _wrap_Fl_Help_Dialog_position, METH_VARARGS, "Fl_Help_Dialog_position(Fl_Help_Dialog self, int xx, int yy)"},
	 { "Fl_Help_Dialog_resize", _wrap_Fl_Help_Dialog_resize, METH_VARARGS, "Fl_Help_Dialog_resize(Fl_Help_Dialog self, int xx, int yy, int ww, int hh)"},
	 { "Fl_Help_Dialog_show", _wrap_Fl_Help_Dialog_show, METH_VARARGS, "\n"
		"Fl_Help_Dialog_show(Fl_Help_Dialog self)\n"
		"Fl_Help_Dialog_show(Fl_Help_Dialog self, int argc, char ** argv)\n"
		""},
	 { "Fl_Help_Dialog_textsize", _wrap_Fl_Help_Dialog_textsize, METH_VARARGS, "\n"
		"Fl_Help_Dialog_textsize(Fl_Help_Dialog self, Fl_Fontsize s)\n"
		"Fl_Help_Dialog_textsize(Fl_Help_Dialog self) -> Fl_Fontsize\n"
		""},
	 { "Fl_Help_Dialog_topline", _wrap_Fl_Help_Dialog_topline, METH_VARARGS, "\n"
		"Fl_Help_Dialog_topline(Fl_Help_Dialog self, char const * n)\n"
		"Fl_Help_Dialog_topline(Fl_Help_Dialog self, int n)\n"
		""},
	 { "Fl_Help_Dialog_value", _wrap_Fl_Help_Dialog_value, METH_VARARGS, "\n"
		"Fl_Help_Dialog_value(Fl_Help_Dialog self, char const * f)\n"
		"Fl_Help_Dialog_value(Fl_Help_Dialog self) -> char const *\n"
		""},
	 { "Fl_Help_Dialog_visible", _wrap_Fl_Help_Dialog_visible, METH_O, "Fl_Help_Dialog_visible(Fl_Help_Dialog self) -> int"},
	 { "Fl_Help_Dialog_w", _wrap_Fl_Help_Dialog_w, METH_O, "Fl_Help_Dialog_w(Fl_Help_Dialog self) -> int"},
	 { "Fl_Help_Dialog_x", _wrap_Fl_Help_Dialog_x, METH_O, "Fl_Help_Dialog_x(Fl_Help_Dialog self) -> int"},
	 { "Fl_Help_Dialog_y", _wrap_Fl_Help_Dialog_y, METH_O, "Fl_Help_Dialog_y(Fl_Help_Dialog self) -> int"},
	 { "Fl_Help_Dialog_swigregister", Fl_Help_Dialog_swigregister, METH_O, NULL},
	 { "Fl_Help_Dialog_swiginit", Fl_Help_Dialog_swiginit, METH_VARARGS, NULL},
	 { "Fl_Help_View_draw", _wrap_Fl_Help_View_draw, METH_O, "Fl_Help_View_draw(Fl_Help_View self)"},
	 { "new_Fl_Help_View", _wrap_new_Fl_Help_View, METH_VARARGS, "new_Fl_Help_View(PyObject * _self, int xx, int yy, int ww, int hh, char const * l=None) -> Fl_Help_View"},
	 { "delete_Fl_Help_View", _wrap_delete_Fl_Help_View, METH_O, "delete_Fl_Help_View(Fl_Help_View self)"},
	 { "Fl_Help_View_handle", _wrap_Fl_Help_View_handle, METH_VARARGS, "Fl_Help_View_handle(Fl_Help_View self, int arg0) -> int"},
	 { "Fl_Help_View_resize", _wrap_Fl_Help_View_resize, METH_VARARGS, "Fl_Help_View_resize(Fl_Help_View self, int arg0, int arg1, int arg2, int arg3)"},
	 { "Fl_Help_View_value", _wrap_Fl_Help_View_value, METH_VARARGS, "\n"
		"Fl_Help_View_value(Fl_Help_View self, char const * val)\n"
		"Fl_Help_View_value(Fl_Help_View self) -> char const *\n"
		""},
	 { "Fl_Help_View_load", _wrap_Fl_Help_View_load, METH_VARARGS, "Fl_Help_View_load(Fl_Help_View self, char const * f) -> int"},
	 { "Fl_Help_View_find", _wrap_Fl_Help_View_find, METH_VARARGS, "Fl_Help_View_find(Fl_Help_View self, char const * s, int p=0) -> int"},
	 { "Fl_Help_View_filename", _wrap_Fl_Help_View_filename, METH_O, "Fl_Help_View_filename(Fl_Help_View self) -> char const *"},
	 { "Fl_Help_View_directory", _wrap_Fl_Help_View_directory, METH_O, "Fl_Help_View_directory(Fl_Help_View self) -> char const *"},
	 { "Fl_Help_View_title", _wrap_Fl_Help_View_title, METH_O, "Fl_Help_View_title(Fl_Help_View self) -> char const *"},
	 { "Fl_Help_View_size", _wrap_Fl_Help_View_size, METH_VARARGS, "\n"
		"Fl_Help_View_size(Fl_Help_View self, int W, int H)\n"
		"Fl_Help_View_size(Fl_Help_View self) -> int\n"
		""},
	 { "Fl_Help_View_textcolor", _wrap_Fl_Help_View_textcolor, METH_VARARGS, "\n"
		"Fl_Help_View_textcolor(Fl_Help_View self, Fl_Color c)\n"
		"Fl_Help_View_textcolor(Fl_Help_View self) -> Fl_Color\n"
		""},
	 { "Fl_Help_View_textfont", _wrap_Fl_Help_View_textfont, METH_VARARGS, "\n"
		"Fl_Help_View_textfont(Fl_Help_View self, Fl_Font f)\n"
		"Fl_Help_View_textfont(Fl_Help_View self) -> Fl_Font\n"
		""},
	 { "Fl_Help_View_textsize", _wrap_Fl_Help_View_textsize, METH_VARARGS, "\n"
		"Fl_Help_View_textsize(Fl_Help_View self, Fl_Fontsize s)\n"
		"Fl_Help_View_textsize(Fl_Help_View self) -> Fl_Fontsize\n"
		""},
	 { "Fl_Help_View_topline", _wrap_Fl_Help_View_topline, METH_VARARGS, "\n"
		"Fl_Help_View_topline(Fl_Help_View self, char const * n)\n"
		"Fl_Help_View_topline(Fl_Help_View self, int arg2)\n"
		"Fl_Help_View_topline(Fl_Help_View self) -> int\n"
		""},
	 { "Fl_Help_View_leftline", _wrap_Fl_Help_View_leftline, METH_VARARGS, "\n"
		"Fl_Help_View_leftline(Fl_Help_View self, int arg2)\n"
		"Fl_Help_View_leftline(Fl_Help_View self) -> int\n"
		""},
	 { "Fl_Help_View_clear_selection", _wrap_Fl_Help_View_clear_selection, METH_O, "Fl_Help_View_clear_selection(Fl_Help_View self)"},
	 { "Fl_Help_View_select_all", _wrap_Fl_Help_View_select_all, METH_O, "Fl_Help_View_select_all(Fl_Help_View self)"},
	 { "Fl_Help_View_text_selected", _wrap_Fl_Help_View_text_selected, METH_O, "Fl_Help_View_text_selected(Fl_Help_View self) -> int"},
	 { "Fl_Help_View_copy", _wrap_Fl_Help_View_copy, METH_VARARGS, "Fl_Help_View_copy(Fl_Help_View self, int clipboard=1) -> int"},
	 { "Fl_Help_View_scrollbar_size", _wrap_Fl_Help_View_scrollbar_size, METH_VARARGS, "\n"
		"Fl_Help_View_scrollbar_size(Fl_Help_View self) -> int\n"
		"Fl_Help_View_scrollbar_size(Fl_Help_View self, int newSize)\n"
		""},
	 { "Fl_Help_View_scrollbar", _wrap_Fl_Help_View_scrollbar, METH_O, "Fl_Help_View_scrollbar(Fl_Help_View self) -> Fl_Scrollbar"},
	 { "Fl_Help_View_hscrollbar", _wrap_Fl_Help_View_hscrollbar, METH_O, "Fl_Help_View_hscrollbar(Fl_Help_View self) -> Fl_Scrollbar"},
	 { "Fl_Help_View_init_type", _wrap_Fl_Help_View_init_type, METH_VARARGS, "Fl_Help_View_init_type(Fl_Help_View self, char * Fl_Help_View)"},
	 { "Fl_Help_View_link", _wrap_Fl_Help_View_link, METH_VARARGS, "\n"
		"Fl_Help_View_link(Fl_Help_View self, Fl_Help_Func * fn)\n"
		"Fl_Help_View_link(Fl_Help_View self, PyObject * PyFunc, PyObject * PyWidget)\n"
		""},
	 { "disown_Fl_Help_View", _wrap_disown_Fl_Help_View, METH_O, NULL},
	 { "Fl_Help_View_swigregister", Fl_Help_View_swigregister, METH_O, NULL},
	 { "Fl_Help_View_swiginit", Fl_Help_View_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Hold_Browser", _wrap_new_Fl_Hold_Browser, METH_VARARGS, "new_Fl_Hold_Browser(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Hold_Browser"},
	 { "Fl_Hold_Browser_init_type", _wrap_Fl_Hold_Browser_init_type, METH_VARARGS, "Fl_Hold_Browser_init_type(Fl_Hold_Browser self, char * Fl_Hold_Browser)"},
	 { "delete_Fl_Hold_Browser", _wrap_delete_Fl_Hold_Browser, METH_O, "delete_Fl_Hold_Browser(Fl_Hold_Browser self)"},
	 { "disown_Fl_Hold_Browser", _wrap_disown_Fl_Hold_Browser, METH_O, NULL},
	 { "Fl_Hold_Browser_draw", _wrap_Fl_Hold_Browser_draw, METH_O, "Fl_Hold_Browser_draw(Fl_Hold_Browser self)"},
	 { "Fl_Hold_Browser_item_first", _wrap_Fl_Hold_Browser_item_first, METH_O, "Fl_Hold_Browser_item_first(Fl_Hold_Browser self) -> void *"},
	 { "Fl_Hold_Browser_item_next", _wrap_Fl_Hold_Browser_item_next, METH_VARARGS, "Fl_Hold_Browser_item_next(Fl_Hold_Browser self, void * item) -> void *"},
	 { "Fl_Hold_Browser_item_prev", _wrap_Fl_Hold_Browser_item_prev, METH_VARARGS, "Fl_Hold_Browser_item_prev(Fl_Hold_Browser self, void * item) -> void *"},
	 { "Fl_Hold_Browser_item_last", _wrap_Fl_Hold_Browser_item_last, METH_O, "Fl_Hold_Browser_item_last(Fl_Hold_Browser self) -> void *"},
	 { "Fl_Hold_Browser_item_height", _wrap_Fl_Hold_Browser_item_height, METH_VARARGS, "Fl_Hold_Browser_item_height(Fl_Hold_Browser self, void * item) -> int"},
	 { "Fl_Hold_Browser_item_width", _wrap_Fl_Hold_Browser_item_width, METH_VARARGS, "Fl_Hold_Browser_item_width(Fl_Hold_Browser self, void * item) -> int"},
	 { "Fl_Hold_Browser_item_quick_height", _wrap_Fl_Hold_Browser_item_quick_height, METH_VARARGS, "Fl_Hold_Browser_item_quick_height(Fl_Hold_Browser self, void * item) -> int"},
	 { "Fl_Hold_Browser_item_draw", _wrap_Fl_Hold_Browser_item_draw, METH_VARARGS, "Fl_Hold_Browser_item_draw(Fl_Hold_Browser self, void * item, int X, int Y, int W, int H)"},
	 { "Fl_Hold_Browser_item_text", _wrap_Fl_Hold_Browser_item_text, METH_VARARGS, "Fl_Hold_Browser_item_text(Fl_Hold_Browser self, void * item) -> char const *"},
	 { "Fl_Hold_Browser_item_swap", _wrap_Fl_Hold_Browser_item_swap, METH_VARARGS, "Fl_Hold_Browser_item_swap(Fl_Hold_Browser self, void * a, void * b)"},
	 { "Fl_Hold_Browser_item_at", _wrap_Fl_Hold_Browser_item_at, METH_VARARGS, "Fl_Hold_Browser_item_at(Fl_Hold_Browser self, int line) -> void *"},
	 { "Fl_Hold_Browser_full_width", _wrap_Fl_Hold_Browser_full_width, METH_O, "Fl_Hold_Browser_full_width(Fl_Hold_Browser self) -> int"},
	 { "Fl_Hold_Browser_full_height", _wrap_Fl_Hold_Browser_full_height, METH_O, "Fl_Hold_Browser_full_height(Fl_Hold_Browser self) -> int"},
	 { "Fl_Hold_Browser_incr_height", _wrap_Fl_Hold_Browser_incr_height, METH_O, "Fl_Hold_Browser_incr_height(Fl_Hold_Browser self) -> int"},
	 { "Fl_Hold_Browser_item_select", _wrap_Fl_Hold_Browser_item_select, METH_VARARGS, "Fl_Hold_Browser_item_select(Fl_Hold_Browser self, void * item, int val)"},
	 { "Fl_Hold_Browser_item_selected", _wrap_Fl_Hold_Browser_item_selected, METH_VARARGS, "Fl_Hold_Browser_item_selected(Fl_Hold_Browser self, void * item) -> int"},
	 { "Fl_Hold_Browser_swigregister", Fl_Hold_Browser_swigregister, METH_O, NULL},
	 { "Fl_Hold_Browser_swiginit", Fl_Hold_Browser_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Hor_Fill_Slider", _wrap_new_Fl_Hor_Fill_Slider, METH_VARARGS, "new_Fl_Hor_Fill_Slider(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Hor_Fill_Slider"},
	 { "Fl_Hor_Fill_Slider_init_type", _wrap_Fl_Hor_Fill_Slider_init_type, METH_VARARGS, "Fl_Hor_Fill_Slider_init_type(Fl_Hor_Fill_Slider self, char * Fl_Hor_Fill_Slider)"},
	 { "delete_Fl_Hor_Fill_Slider", _wrap_delete_Fl_Hor_Fill_Slider, METH_O, "delete_Fl_Hor_Fill_Slider(Fl_Hor_Fill_Slider self)"},
	 { "disown_Fl_Hor_Fill_Slider", _wrap_disown_Fl_Hor_Fill_Slider, METH_O, NULL},
	 { "Fl_Hor_Fill_Slider_draw", _wrap_Fl_Hor_Fill_Slider_draw, METH_O, "Fl_Hor_Fill_Slider_draw(Fl_Hor_Fill_Slider self)"},
	 { "Fl_Hor_Fill_Slider_swigregister", Fl_Hor_Fill_Slider_swigregister, METH_O, NULL},
	 { "Fl_Hor_Fill_Slider_swiginit", Fl_Hor_Fill_Slider_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Hor_Nice_Slider", _wrap_new_Fl_Hor_Nice_Slider, METH_VARARGS, "new_Fl_Hor_Nice_Slider(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Hor_Nice_Slider"},
	 { "Fl_Hor_Nice_Slider_init_type", _wrap_Fl_Hor_Nice_Slider_init_type, METH_VARARGS, "Fl_Hor_Nice_Slider_init_type(Fl_Hor_Nice_Slider self, char * Fl_Hor_Nice_Slider)"},
	 { "delete_Fl_Hor_Nice_Slider", _wrap_delete_Fl_Hor_Nice_Slider, METH_O, "delete_Fl_Hor_Nice_Slider(Fl_Hor_Nice_Slider self)"},
	 { "disown_Fl_Hor_Nice_Slider", _wrap_disown_Fl_Hor_Nice_Slider, METH_O, NULL},
	 { "Fl_Hor_Nice_Slider_draw", _wrap_Fl_Hor_Nice_Slider_draw, METH_O, "Fl_Hor_Nice_Slider_draw(Fl_Hor_Nice_Slider self)"},
	 { "Fl_Hor_Nice_Slider_swigregister", Fl_Hor_Nice_Slider_swigregister, METH_O, NULL},
	 { "Fl_Hor_Nice_Slider_swiginit", Fl_Hor_Nice_Slider_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Hor_Slider", _wrap_new_Fl_Hor_Slider, METH_VARARGS, "new_Fl_Hor_Slider(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Hor_Slider"},
	 { "Fl_Hor_Slider_init_type", _wrap_Fl_Hor_Slider_init_type, METH_VARARGS, "Fl_Hor_Slider_init_type(Fl_Hor_Slider self, char * Fl_Hor_Slider)"},
	 { "delete_Fl_Hor_Slider", _wrap_delete_Fl_Hor_Slider, METH_O, "delete_Fl_Hor_Slider(Fl_Hor_Slider self)"},
	 { "disown_Fl_Hor_Slider", _wrap_disown_Fl_Hor_Slider, METH_O, NULL},
	 { "Fl_Hor_Slider_draw", _wrap_Fl_Hor_Slider_draw, METH_O, "Fl_Hor_Slider_draw(Fl_Hor_Slider self)"},
	 { "Fl_Hor_Slider_swigregister", Fl_Hor_Slider_swigregister, METH_O, NULL},
	 { "Fl_Hor_Slider_swiginit", Fl_Hor_Slider_swiginit, METH_VARARGS, NULL},
	 { "Fl_Value_Slider_draw", _wrap_Fl_Value_Slider_draw, METH_O, "Fl_Value_Slider_draw(Fl_Value_Slider self)"},
	 { "Fl_Value_Slider_handle", _wrap_Fl_Value_Slider_handle, METH_VARARGS, "Fl_Value_Slider_handle(Fl_Value_Slider self, int arg0) -> int"},
	 { "new_Fl_Value_Slider", _wrap_new_Fl_Value_Slider, METH_VARARGS, "new_Fl_Value_Slider(PyObject * _self, int x, int y, int w, int h, char const * l=None) -> Fl_Value_Slider"},
	 { "Fl_Value_Slider_textfont", _wrap_Fl_Value_Slider_textfont, METH_VARARGS, "\n"
		"Fl_Value_Slider_textfont(Fl_Value_Slider self) -> Fl_Font\n"
		"Fl_Value_Slider_textfont(Fl_Value_Slider self, Fl_Font s)\n"
		""},
	 { "Fl_Value_Slider_textsize", _wrap_Fl_Value_Slider_textsize, METH_VARARGS, "\n"
		"Fl_Value_Slider_textsize(Fl_Value_Slider self) -> Fl_Fontsize\n"
		"Fl_Value_Slider_textsize(Fl_Value_Slider self, Fl_Fontsize s)\n"
		""},
	 { "Fl_Value_Slider_textcolor", _wrap_Fl_Value_Slider_textcolor, METH_VARARGS, "\n"
		"Fl_Value_Slider_textcolor(Fl_Value_Slider self) -> Fl_Color\n"
		"Fl_Value_Slider_textcolor(Fl_Value_Slider self, Fl_Color s)\n"
		""},
	 { "Fl_Value_Slider_value_width", _wrap_Fl_Value_Slider_value_width, METH_VARARGS, "\n"
		"Fl_Value_Slider_value_width(Fl_Value_Slider self, int s)\n"
		"Fl_Value_Slider_value_width(Fl_Value_Slider self) -> int\n"
		""},
	 { "Fl_Value_Slider_value_height", _wrap_Fl_Value_Slider_value_height, METH_VARARGS, "\n"
		"Fl_Value_Slider_value_height(Fl_Value_Slider self, int s)\n"
		"Fl_Value_Slider_value_height(Fl_Value_Slider self) -> int\n"
		""},
	 { "Fl_Value_Slider_init_type", _wrap_Fl_Value_Slider_init_type, METH_VARARGS, "Fl_Value_Slider_init_type(Fl_Value_Slider self, char * Fl_Value_Slider)"},
	 { "delete_Fl_Value_Slider", _wrap_delete_Fl_Value_Slider, METH_O, "delete_Fl_Value_Slider(Fl_Value_Slider self)"},
	 { "disown_Fl_Value_Slider", _wrap_disown_Fl_Value_Slider, METH_O, NULL},
	 { "Fl_Value_Slider_swigregister", Fl_Value_Slider_swigregister, METH_O, NULL},
	 { "Fl_Value_Slider_swiginit", Fl_Value_Slider_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Hor_Value_Slider", _wrap_new_Fl_Hor_Value_Slider, METH_VARARGS, "new_Fl_Hor_Value_Slider(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Hor_Value_Slider"},
	 { "Fl_Hor_Value_Slider_init_type", _wrap_Fl_Hor_Value_Slider_init_type, METH_VARARGS, "Fl_Hor_Value_Slider_init_type(Fl_Hor_Value_Slider self, char * Fl_Hor_Value_Slider)"},
	 { "delete_Fl_Hor_Value_Slider", _wrap_delete_Fl_Hor_Value_Slider, METH_O, "delete_Fl_Hor_Value_Slider(Fl_Hor_Value_Slider self)"},
	 { "disown_Fl_Hor_Value_Slider", _wrap_disown_Fl_Hor_Value_Slider, METH_O, NULL},
	 { "Fl_Hor_Value_Slider_draw", _wrap_Fl_Hor_Value_Slider_draw, METH_O, "Fl_Hor_Value_Slider_draw(Fl_Hor_Value_Slider self)"},
	 { "Fl_Hor_Value_Slider_swigregister", Fl_Hor_Value_Slider_swigregister, METH_O, NULL},
	 { "Fl_Hor_Value_Slider_swiginit", Fl_Hor_Value_Slider_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Int_Input", _wrap_new_Fl_Int_Input, METH_VARARGS, "new_Fl_Int_Input(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Int_Input"},
	 { "Fl_Int_Input_init_type", _wrap_Fl_Int_Input_init_type, METH_VARARGS, "Fl_Int_Input_init_type(Fl_Int_Input self, char * Fl_Int_Input)"},
	 { "delete_Fl_Int_Input", _wrap_delete_Fl_Int_Input, METH_O, "delete_Fl_Int_Input(Fl_Int_Input self)"},
	 { "disown_Fl_Int_Input", _wrap_disown_Fl_Int_Input, METH_O, NULL},
	 { "Fl_Int_Input_draw", _wrap_Fl_Int_Input_draw, METH_O, "Fl_Int_Input_draw(Fl_Int_Input self)"},
	 { "Fl_Int_Input_swigregister", Fl_Int_Input_swigregister, METH_O, NULL},
	 { "Fl_Int_Input_swiginit", Fl_Int_Input_swiginit, METH_VARARGS, NULL},
	 { "Fl_Input_Choice_inp_x", _wrap_Fl_Input_Choice_inp_x, METH_O, "Fl_Input_Choice_inp_x(Fl_Input_Choice self) -> int"},
	 { "Fl_Input_Choice_inp_y", _wrap_Fl_Input_Choice_inp_y, METH_O, "Fl_Input_Choice_inp_y(Fl_Input_Choice self) -> int"},
	 { "Fl_Input_Choice_inp_w", _wrap_Fl_Input_Choice_inp_w, METH_O, "Fl_Input_Choice_inp_w(Fl_Input_Choice self) -> int"},
	 { "Fl_Input_Choice_inp_h", _wrap_Fl_Input_Choice_inp_h, METH_O, "Fl_Input_Choice_inp_h(Fl_Input_Choice self) -> int"},
	 { "Fl_Input_Choice_menu_x", _wrap_Fl_Input_Choice_menu_x, METH_O, "Fl_Input_Choice_menu_x(Fl_Input_Choice self) -> int"},
	 { "Fl_Input_Choice_menu_y", _wrap_Fl_Input_Choice_menu_y, METH_O, "Fl_Input_Choice_menu_y(Fl_Input_Choice self) -> int"},
	 { "Fl_Input_Choice_menu_w", _wrap_Fl_Input_Choice_menu_w, METH_O, "Fl_Input_Choice_menu_w(Fl_Input_Choice self) -> int"},
	 { "Fl_Input_Choice_menu_h", _wrap_Fl_Input_Choice_menu_h, METH_O, "Fl_Input_Choice_menu_h(Fl_Input_Choice self) -> int"},
	 { "Fl_Input_Choice_draw", _wrap_Fl_Input_Choice_draw, METH_O, "Fl_Input_Choice_draw(Fl_Input_Choice self)"},
	 { "new_Fl_Input_Choice", _wrap_new_Fl_Input_Choice, METH_VARARGS, "new_Fl_Input_Choice(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Input_Choice"},
	 { "Fl_Input_Choice_resize", _wrap_Fl_Input_Choice_resize, METH_VARARGS, "Fl_Input_Choice_resize(Fl_Input_Choice self, int X, int Y, int W, int H)"},
	 { "Fl_Input_Choice_add", _wrap_Fl_Input_Choice_add, METH_VARARGS, "Fl_Input_Choice_add(Fl_Input_Choice self, char const * s)"},
	 { "Fl_Input_Choice_changed", _wrap_Fl_Input_Choice_changed, METH_O, "Fl_Input_Choice_changed(Fl_Input_Choice self) -> int"},
	 { "Fl_Input_Choice_clear_changed", _wrap_Fl_Input_Choice_clear_changed, METH_O, "Fl_Input_Choice_clear_changed(Fl_Input_Choice self)"},
	 { "Fl_Input_Choice_set_changed", _wrap_Fl_Input_Choice_set_changed, METH_O, "Fl_Input_Choice_set_changed(Fl_Input_Choice self)"},
	 { "Fl_Input_Choice_clear", _wrap_Fl_Input_Choice_clear, METH_O, "Fl_Input_Choice_clear(Fl_Input_Choice self)"},
	 { "Fl_Input_Choice_down_box", _wrap_Fl_Input_Choice_down_box, METH_VARARGS, "\n"
		"Fl_Input_Choice_down_box(Fl_Input_Choice self) -> Fl_Boxtype\n"
		"Fl_Input_Choice_down_box(Fl_Input_Choice self, Fl_Boxtype b)\n"
		""},
	 { "Fl_Input_Choice_menu", _wrap_Fl_Input_Choice_menu, METH_VARARGS, "\n"
		"Fl_Input_Choice_menu(Fl_Input_Choice self) -> Fl_Menu_Item\n"
		"Fl_Input_Choice_menu(Fl_Input_Choice self, Fl_Menu_Item m)\n"
		""},
	 { "Fl_Input_Choice_textcolor", _wrap_Fl_Input_Choice_textcolor, METH_VARARGS, "\n"
		"Fl_Input_Choice_textcolor(Fl_Input_Choice self) -> Fl_Color\n"
		"Fl_Input_Choice_textcolor(Fl_Input_Choice self, Fl_Color c)\n"
		""},
	 { "Fl_Input_Choice_textfont", _wrap_Fl_Input_Choice_textfont, METH_VARARGS, "\n"
		"Fl_Input_Choice_textfont(Fl_Input_Choice self) -> Fl_Font\n"
		"Fl_Input_Choice_textfont(Fl_Input_Choice self, Fl_Font f)\n"
		""},
	 { "Fl_Input_Choice_textsize", _wrap_Fl_Input_Choice_textsize, METH_VARARGS, "\n"
		"Fl_Input_Choice_textsize(Fl_Input_Choice self) -> Fl_Fontsize\n"
		"Fl_Input_Choice_textsize(Fl_Input_Choice self, Fl_Fontsize s)\n"
		""},
	 { "Fl_Input_Choice_value", _wrap_Fl_Input_Choice_value, METH_VARARGS, "\n"
		"Fl_Input_Choice_value(Fl_Input_Choice self) -> char const\n"
		"Fl_Input_Choice_value(Fl_Input_Choice self, char const * val)\n"
		"Fl_Input_Choice_value(Fl_Input_Choice self, int val)\n"
		""},
	 { "Fl_Input_Choice_update_menubutton", _wrap_Fl_Input_Choice_update_menubutton, METH_O, "Fl_Input_Choice_update_menubutton(Fl_Input_Choice self) -> int"},
	 { "Fl_Input_Choice_menubutton", _wrap_Fl_Input_Choice_menubutton, METH_O, "Fl_Input_Choice_menubutton(Fl_Input_Choice self) -> Fl_Menu_Button"},
	 { "Fl_Input_Choice_input", _wrap_Fl_Input_Choice_input, METH_O, "Fl_Input_Choice_input(Fl_Input_Choice self) -> Fl_Input"},
	 { "Fl_Input_Choice_init_type", _wrap_Fl_Input_Choice_init_type, METH_VARARGS, "Fl_Input_Choice_init_type(Fl_Input_Choice self, char * Fl_Input_Choice)"},
	 { "delete_Fl_Input_Choice", _wrap_delete_Fl_Input_Choice, METH_O, "delete_Fl_Input_Choice(Fl_Input_Choice self)"},
	 { "disown_Fl_Input_Choice", _wrap_disown_Fl_Input_Choice, METH_O, NULL},
	 { "Fl_Input_Choice_swigregister", Fl_Input_Choice_swigregister, METH_O, NULL},
	 { "Fl_Input_Choice_swiginit", Fl_Input_Choice_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_JPEG_Image", _wrap_new_Fl_JPEG_Image, METH_VARARGS, "\n"
		"Fl_JPEG_Image(char const * filename)\n"
		"new_Fl_JPEG_Image(PyObject * _self, char const * name, unsigned char const * data, int data_length=-1) -> Fl_JPEG_Image\n"
		""},
	 { "delete_Fl_JPEG_Image", _wrap_delete_Fl_JPEG_Image, METH_O, "delete_Fl_JPEG_Image(Fl_JPEG_Image self)"},
	 { "disown_Fl_JPEG_Image", _wrap_disown_Fl_JPEG_Image, METH_O, NULL},
	 { "Fl_JPEG_Image_swigregister", Fl_JPEG_Image_swigregister, METH_O, NULL},
	 { "Fl_JPEG_Image_swiginit", Fl_JPEG_Image_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Line_Dial", _wrap_new_Fl_Line_Dial, METH_VARARGS, "new_Fl_Line_Dial(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Line_Dial"},
	 { "Fl_Line_Dial_init_type", _wrap_Fl_Line_Dial_init_type, METH_VARARGS, "Fl_Line_Dial_init_type(Fl_Line_Dial self, char * Fl_Line_Dial)"},
	 { "delete_Fl_Line_Dial", _wrap_delete_Fl_Line_Dial, METH_O, "delete_Fl_Line_Dial(Fl_Line_Dial self)"},
	 { "disown_Fl_Line_Dial", _wrap_disown_Fl_Line_Dial, METH_O, NULL},
	 { "Fl_Line_Dial_draw", _wrap_Fl_Line_Dial_draw, METH_O, "Fl_Line_Dial_draw(Fl_Line_Dial self)"},
	 { "Fl_Line_Dial_swigregister", Fl_Line_Dial_swigregister, METH_O, NULL},
	 { "Fl_Line_Dial_swiginit", Fl_Line_Dial_swiginit, METH_VARARGS, NULL},
	 { "Fl_Menu_Bar_draw", _wrap_Fl_Menu_Bar_draw, METH_O, "Fl_Menu_Bar_draw(Fl_Menu_Bar self)"},
	 { "Fl_Menu_Bar_handle", _wrap_Fl_Menu_Bar_handle, METH_VARARGS, "Fl_Menu_Bar_handle(Fl_Menu_Bar self, int arg0) -> int"},
	 { "new_Fl_Menu_Bar", _wrap_new_Fl_Menu_Bar, METH_VARARGS, "new_Fl_Menu_Bar(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Menu_Bar"},
	 { "Fl_Menu_Bar_update", _wrap_Fl_Menu_Bar_update, METH_O, "Fl_Menu_Bar_update(Fl_Menu_Bar self)"},
	 { "Fl_Menu_Bar_play_menu", _wrap_Fl_Menu_Bar_play_menu, METH_VARARGS, "Fl_Menu_Bar_play_menu(Fl_Menu_Bar self, Fl_Menu_Item item)"},
	 { "Fl_Menu_Bar_init_type", _wrap_Fl_Menu_Bar_init_type, METH_VARARGS, "Fl_Menu_Bar_init_type(Fl_Menu_Bar self, char * Fl_Menu_Bar)"},
	 { "delete_Fl_Menu_Bar", _wrap_delete_Fl_Menu_Bar, METH_O, "delete_Fl_Menu_Bar(Fl_Menu_Bar self)"},
	 { "disown_Fl_Menu_Bar", _wrap_disown_Fl_Menu_Bar, METH_O, NULL},
	 { "Fl_Menu_Bar_swigregister", Fl_Menu_Bar_swigregister, METH_O, NULL},
	 { "Fl_Menu_Bar_swiginit", Fl_Menu_Bar_swiginit, METH_VARARGS, NULL},
	 { "Fl_Menu_Button_draw", _wrap_Fl_Menu_Button_draw, METH_O, "Fl_Menu_Button_draw(Fl_Menu_Button self)"},
	 { "Fl_Menu_Button_handle", _wrap_Fl_Menu_Button_handle, METH_VARARGS, "Fl_Menu_Button_handle(Fl_Menu_Button self, int arg0) -> int"},
	 { "Fl_Menu_Button_popup", _wrap_Fl_Menu_Button_popup, METH_O, "Fl_Menu_Button_popup(Fl_Menu_Button self) -> Fl_Menu_Item"},
	 { "new_Fl_Menu_Button", _wrap_new_Fl_Menu_Button, METH_VARARGS, "new_Fl_Menu_Button(PyObject * _self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Menu_Button"},
	 { "Fl_Menu_Button_init_type", _wrap_Fl_Menu_Button_init_type, METH_VARARGS, "Fl_Menu_Button_init_type(Fl_Menu_Button self, char * Fl_Menu_Button)"},
	 { "delete_Fl_Menu_Button", _wrap_delete_Fl_Menu_Button, METH_O, "delete_Fl_Menu_Button(Fl_Menu_Button self)"},
	 { "disown_Fl_Menu_Button", _wrap_disown_Fl_Menu_Button, METH_O, NULL},
	 { "Fl_Menu_Button_swigregister", Fl_Menu_Button_swigregister, METH_O, NULL},
	 { "Fl_Menu_Button_swiginit", Fl_Menu_Button_swiginit, METH_VARARGS, NULL},
	 { "Fl_Menu_Item_next", _wrap_Fl_Menu_Item_next, METH_VARARGS, "\n"
		"Fl_Menu_Item_next(Fl_Menu_Item self, int arg2=1) -> Fl_Menu_Item\n"
		"Fl_Menu_Item_next(Fl_Menu_Item self, int i=1) -> Fl_Menu_Item\n"
		""},
	 { "Fl_Menu_Item_first", _wrap_Fl_Menu_Item_first, METH_VARARGS, "\n"
		"Fl_Menu_Item_first(Fl_Menu_Item self) -> Fl_Menu_Item\n"
		"Fl_Menu_Item_first(Fl_Menu_Item self) -> Fl_Menu_Item\n"
		""},
	 { "Fl_Menu_Item_label", _wrap_Fl_Menu_Item_label, METH_VARARGS, "\n"
		"Fl_Menu_Item_label(Fl_Menu_Item self) -> char const\n"
		"Fl_Menu_Item_label(Fl_Menu_Item self, char const * a)\n"
		"Fl_Menu_Item_label(Fl_Menu_Item self, Fl_Labeltype a, char const * b)\n"
		""},
	 { "Fl_Menu_Item_multi_label", _wrap_Fl_Menu_Item_multi_label, METH_VARARGS, "Fl_Menu_Item_multi_label(Fl_Menu_Item self, Fl_Multi_Label ml)"},
	 { "Fl_Menu_Item_image_label", _wrap_Fl_Menu_Item_image_label, METH_VARARGS, "Fl_Menu_Item_image_label(Fl_Menu_Item self, Fl_Image image)"},
	 { "Fl_Menu_Item_labeltype", _wrap_Fl_Menu_Item_labeltype, METH_VARARGS, "\n"
		"Fl_Menu_Item_labeltype(Fl_Menu_Item self) -> Fl_Labeltype\n"
		"Fl_Menu_Item_labeltype(Fl_Menu_Item self, Fl_Labeltype a)\n"
		""},
	 { "Fl_Menu_Item_labelcolor", _wrap_Fl_Menu_Item_labelcolor, METH_VARARGS, "\n"
		"Fl_Menu_Item_labelcolor(Fl_Menu_Item self) -> Fl_Color\n"
		"Fl_Menu_Item_labelcolor(Fl_Menu_Item self, Fl_Color a)\n"
		""},
	 { "Fl_Menu_Item_labelfont", _wrap_Fl_Menu_Item_labelfont, METH_VARARGS, "\n"
		"Fl_Menu_Item_labelfont(Fl_Menu_Item self) -> Fl_Font\n"
		"Fl_Menu_Item_labelfont(Fl_Menu_Item self, Fl_Font a)\n"
		""},
	 { "Fl_Menu_Item_labelsize", _wrap_Fl_Menu_Item_labelsize, METH_VARARGS, "\n"
		"Fl_Menu_Item_labelsize(Fl_Menu_Item self) -> Fl_Fontsize\n"
		"Fl_Menu_Item_labelsize(Fl_Menu_Item self, Fl_Fontsize a)\n"
		""},
	 { "Fl_Menu_Item_argument", _wrap_Fl_Menu_Item_argument, METH_VARARGS, "\n"
		"Fl_Menu_Item_argument(Fl_Menu_Item self) -> long\n"
		"Fl_Menu_Item_argument(Fl_Menu_Item self, long v)\n"
		""},
	 { "Fl_Menu_Item_shortcut", _wrap_Fl_Menu_Item_shortcut, METH_VARARGS, "\n"
		"Fl_Menu_Item_shortcut(Fl_Menu_Item self) -> int\n"
		"Fl_Menu_Item_shortcut(Fl_Menu_Item self, int s)\n"
		""},
	 { "Fl_Menu_Item_submenu", _wrap_Fl_Menu_Item_submenu, METH_O, "Fl_Menu_Item_submenu(Fl_Menu_Item self) -> int"},
	 { "Fl_Menu_Item_checkbox", _wrap_Fl_Menu_Item_checkbox, METH_O, "Fl_Menu_Item_checkbox(Fl_Menu_Item self) -> int"},
	 { "Fl_Menu_Item_radio", _wrap_Fl_Menu_Item_radio, METH_O, "Fl_Menu_Item_radio(Fl_Menu_Item self) -> int"},
	 { "Fl_Menu_Item_value", _wrap_Fl_Menu_Item_value, METH_VARARGS, "\n"
		"Fl_Menu_Item_value(Fl_Menu_Item self) -> int\n"
		"Fl_Menu_Item_value(Fl_Menu_Item self, int v)\n"
		""},
	 { "Fl_Menu_Item_set", _wrap_Fl_Menu_Item_set, METH_O, "Fl_Menu_Item_set(Fl_Menu_Item self)"},
	 { "Fl_Menu_Item_clear", _wrap_Fl_Menu_Item_clear, METH_O, "Fl_Menu_Item_clear(Fl_Menu_Item self)"},
	 { "Fl_Menu_Item_setonly", _wrap_Fl_Menu_Item_setonly, METH_VARARGS, "\n"
		"Fl_Menu_Item_setonly(Fl_Menu_Item self)\n"
		"Fl_Menu_Item_setonly(Fl_Menu_Item self, Fl_Menu_Item first)\n"
		""},
	 { "Fl_Menu_Item_visible", _wrap_Fl_Menu_Item_visible, METH_O, "Fl_Menu_Item_visible(Fl_Menu_Item self) -> int"},
	 { "Fl_Menu_Item_show", _wrap_Fl_Menu_Item_show, METH_O, "Fl_Menu_Item_show(Fl_Menu_Item self)"},
	 { "Fl_Menu_Item_hide", _wrap_Fl_Menu_Item_hide, METH_O, "Fl_Menu_Item_hide(Fl_Menu_Item self)"},
	 { "Fl_Menu_Item_active", _wrap_Fl_Menu_Item_active, METH_O, "Fl_Menu_Item_active(Fl_Menu_Item self) -> int"},
	 { "Fl_Menu_Item_activate", _wrap_Fl_Menu_Item_activate, METH_O, "Fl_Menu_Item_activate(Fl_Menu_Item self)"},
	 { "Fl_Menu_Item_deactivate", _wrap_Fl_Menu_Item_deactivate, METH_O, "Fl_Menu_Item_deactivate(Fl_Menu_Item self)"},
	 { "Fl_Menu_Item_activevisible", _wrap_Fl_Menu_Item_activevisible, METH_O, "Fl_Menu_Item_activevisible(Fl_Menu_Item self) -> int"},
	 { "Fl_Menu_Item_selectable", _wrap_Fl_Menu_Item_selectable, METH_O, "Fl_Menu_Item_selectable(Fl_Menu_Item self) -> int"},
	 { "Fl_Menu_Item_headline", _wrap_Fl_Menu_Item_headline, METH_VARARGS, "\n"
		"Fl_Menu_Item_headline(Fl_Menu_Item self, bool yes)\n"
		"Fl_Menu_Item_headline(Fl_Menu_Item self) -> int\n"
		""},
	 { "Fl_Menu_Item_image", _wrap_Fl_Menu_Item_image, METH_VARARGS, "\n"
		"Fl_Menu_Item_image(Fl_Menu_Item self, Fl_Image image)\n"
		"Fl_Menu_Item_image(Fl_Menu_Item self, Fl_Image image)\n"
		""},
	 { "Fl_Menu_Item_measure", _wrap_Fl_Menu_Item_measure, METH_VARARGS, "Fl_Menu_Item_measure(Fl_Menu_Item self, int * h, Fl_Menu_ arg3) -> int"},
	 { "Fl_Menu_Item_draw", _wrap_Fl_Menu_Item_draw, METH_VARARGS, "Fl_Menu_Item_draw(Fl_Menu_Item self, int x, int y, int w, int h, Fl_Menu_ arg6, int t=0)"},
	 { "Fl_Menu_Item_popup", _wrap_Fl_Menu_Item_popup, METH_VARARGS, "Fl_Menu_Item_popup(Fl_Menu_Item self, int X, int Y, char const * title=None, Fl_Menu_Item picked=None, Fl_Menu_ arg6=None) -> Fl_Menu_Item"},
	 { "Fl_Menu_Item_pulldown", _wrap_Fl_Menu_Item_pulldown, METH_VARARGS, "Fl_Menu_Item_pulldown(Fl_Menu_Item self, int X, int Y, int W, int H, Fl_Menu_Item picked=None, Fl_Menu_ arg7=None, Fl_Menu_Item title=None, int menubar=0) -> Fl_Menu_Item"},
	 { "Fl_Menu_Item_test_shortcut", _wrap_Fl_Menu_Item_test_shortcut, METH_O, "Fl_Menu_Item_test_shortcut(Fl_Menu_Item self) -> Fl_Menu_Item"},
	 { "Fl_Menu_Item_find_shortcut", _wrap_Fl_Menu_Item_find_shortcut, METH_VARARGS, "Fl_Menu_Item_find_shortcut(Fl_Menu_Item self, int * ip=None, bool const require_alt=False) -> Fl_Menu_Item"},
	 { "Fl_Menu_Item_do_callback", _wrap_Fl_Menu_Item_do_callback, METH_VARARGS, "\n"
		"Fl_Menu_Item_do_callback(Fl_Menu_Item self, Fl_Widget o, Fl_Callback_Reason reason=FL_REASON_UNKNOWN)\n"
		"Fl_Menu_Item_do_callback(Fl_Menu_Item self, Fl_Widget o, void * arg, Fl_Callback_Reason reason=FL_REASON_UNKNOWN)\n"
		"Fl_Menu_Item_do_callback(Fl_Menu_Item self, Fl_Widget o, long arg, Fl_Callback_Reason reason=FL_REASON_UNKNOWN)\n"
		""},
	 { "Fl_Menu_Item_insert", _wrap_Fl_Menu_Item_insert, METH_VARARGS, "Fl_Menu_Item_insert(Fl_Menu_Item self, int arg2, char const * arg3, int arg4, Fl_Callback * arg5, void * arg6=None, int arg7=0) -> int"},
	 { "Fl_Menu_Item_add", _wrap_Fl_Menu_Item_add, METH_VARARGS, "\n"
		"Fl_Menu_Item_add(Fl_Menu_Item self, char const * arg2, int shortcut, Fl_Callback * arg4, void * arg5=None, int arg6=0) -> int\n"
		"Fl_Menu_Item_add(Fl_Menu_Item self, char const * a, char const * b, Fl_Callback * c, void * d=None, int e=0) -> int\n"
		""},
	 { "Fl_Menu_Item_size", _wrap_Fl_Menu_Item_size, METH_O, "Fl_Menu_Item_size(Fl_Menu_Item self) -> int"},
	 { "Fl_Menu_Item_callback", _wrap_Fl_Menu_Item_callback, METH_VARARGS, "\n"
		"Fl_Menu_Item_callback(Fl_Menu_Item self, Fl_Callback * c, void * p)\n"
		"Fl_Menu_Item_callback(Fl_Menu_Item self, Fl_Callback * c)\n"
		"Fl_Menu_Item_callback(Fl_Menu_Item self, Fl_Callback0 * c)\n"
		"Fl_Menu_Item_callback(Fl_Menu_Item self, Fl_Callback1 * c, long p=0)\n"
		"Fl_Menu_Item_callback(Fl_Menu_Item self) -> PyObject *\n"
		""},
	 { "Fl_Menu_Item_user_data", _wrap_Fl_Menu_Item_user_data, METH_O, "Fl_Menu_Item_user_data(Fl_Menu_Item self) -> PyObject *"},
	 { "Fl_Menu_Item_add_multi_label", _wrap_Fl_Menu_Item_add_multi_label, METH_VARARGS, "Fl_Menu_Item_add_multi_label(Fl_Menu_Item self, Fl_Pixmap pixmap)"},
	 { "new_Fl_Menu_Item", _wrap_new_Fl_Menu_Item, METH_NOARGS, "new_Fl_Menu_Item() -> Fl_Menu_Item"},
	 { "delete_Fl_Menu_Item", _wrap_delete_Fl_Menu_Item, METH_O, "delete_Fl_Menu_Item(Fl_Menu_Item self)"},
	 { "Fl_Menu_Item_swigregister", Fl_Menu_Item_swigregister, METH_O, NULL},
	 { "Fl_Menu_Item_swiginit", Fl_Menu_Item_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Single_Window", _wrap_new_Fl_Single_Window, METH_VARARGS, "\n"
		"Fl_Single_Window(int W, int H, char const * l=None)\n"
		"new_Fl_Single_Window(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Single_Window\n"
		""},
	 { "Fl_Single_Window_flush", _wrap_Fl_Single_Window_flush, METH_O, "Fl_Single_Window_flush(Fl_Single_Window self)"},
	 { "Fl_Single_Window_init_type", _wrap_Fl_Single_Window_init_type, METH_VARARGS, "Fl_Single_Window_init_type(Fl_Single_Window self, char * Fl_Single_Window)"},
	 { "Fl_Single_Window_show", _wrap_Fl_Single_Window_show, METH_VARARGS, "Fl_Single_Window_show(Fl_Single_Window self, PyObject * count=None, PyObject * data=None)"},
	 { "delete_Fl_Single_Window", _wrap_delete_Fl_Single_Window, METH_O, "delete_Fl_Single_Window(Fl_Single_Window self)"},
	 { "disown_Fl_Single_Window", _wrap_disown_Fl_Single_Window, METH_O, NULL},
	 { "Fl_Single_Window_draw", _wrap_Fl_Single_Window_draw, METH_O, "Fl_Single_Window_draw(Fl_Single_Window self)"},
	 { "Fl_Single_Window_swigregister", Fl_Single_Window_swigregister, METH_O, NULL},
	 { "Fl_Single_Window_swiginit", Fl_Single_Window_swiginit, METH_VARARGS, NULL},
	 { "delete_Fl_Menu_Window", _wrap_delete_Fl_Menu_Window, METH_O, "delete_Fl_Menu_Window(Fl_Menu_Window self)"},
	 { "new_Fl_Menu_Window", _wrap_new_Fl_Menu_Window, METH_VARARGS, "\n"
		"Fl_Menu_Window(int W, int H, char const * l=None)\n"
		"new_Fl_Menu_Window(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Menu_Window\n"
		""},
	 { "Fl_Menu_Window_init_type", _wrap_Fl_Menu_Window_init_type, METH_VARARGS, "Fl_Menu_Window_init_type(Fl_Menu_Window self, char * Fl_Menu_Window)"},
	 { "disown_Fl_Menu_Window", _wrap_disown_Fl_Menu_Window, METH_O, NULL},
	 { "Fl_Menu_Window_draw", _wrap_Fl_Menu_Window_draw, METH_O, "Fl_Menu_Window_draw(Fl_Menu_Window self)"},
	 { "Fl_Menu_Window_swigregister", Fl_Menu_Window_swigregister, METH_O, NULL},
	 { "Fl_Menu_Window_swiginit", Fl_Menu_Window_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Multiline_Input", _wrap_new_Fl_Multiline_Input, METH_VARARGS, "new_Fl_Multiline_Input(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Multiline_Input"},
	 { "Fl_Multiline_Input_init_type", _wrap_Fl_Multiline_Input_init_type, METH_VARARGS, "Fl_Multiline_Input_init_type(Fl_Multiline_Input self, char * Fl_Multiline_Input)"},
	 { "delete_Fl_Multiline_Input", _wrap_delete_Fl_Multiline_Input, METH_O, "delete_Fl_Multiline_Input(Fl_Multiline_Input self)"},
	 { "disown_Fl_Multiline_Input", _wrap_disown_Fl_Multiline_Input, METH_O, NULL},
	 { "Fl_Multiline_Input_draw", _wrap_Fl_Multiline_Input_draw, METH_O, "Fl_Multiline_Input_draw(Fl_Multiline_Input self)"},
	 { "Fl_Multiline_Input_swigregister", Fl_Multiline_Input_swigregister, METH_O, NULL},
	 { "Fl_Multiline_Input_swiginit", Fl_Multiline_Input_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Output", _wrap_new_Fl_Output, METH_VARARGS, "new_Fl_Output(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Output"},
	 { "Fl_Output_init_type", _wrap_Fl_Output_init_type, METH_VARARGS, "Fl_Output_init_type(Fl_Output self, char * Fl_Output)"},
	 { "delete_Fl_Output", _wrap_delete_Fl_Output, METH_O, "delete_Fl_Output(Fl_Output self)"},
	 { "disown_Fl_Output", _wrap_disown_Fl_Output, METH_O, NULL},
	 { "Fl_Output_draw", _wrap_Fl_Output_draw, METH_O, "Fl_Output_draw(Fl_Output self)"},
	 { "Fl_Output_swigregister", Fl_Output_swigregister, METH_O, NULL},
	 { "Fl_Output_swiginit", Fl_Output_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Multiline_Output", _wrap_new_Fl_Multiline_Output, METH_VARARGS, "new_Fl_Multiline_Output(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Multiline_Output"},
	 { "Fl_Multiline_Output_init_type", _wrap_Fl_Multiline_Output_init_type, METH_VARARGS, "Fl_Multiline_Output_init_type(Fl_Multiline_Output self, char * Fl_Multiline_Output)"},
	 { "delete_Fl_Multiline_Output", _wrap_delete_Fl_Multiline_Output, METH_O, "delete_Fl_Multiline_Output(Fl_Multiline_Output self)"},
	 { "disown_Fl_Multiline_Output", _wrap_disown_Fl_Multiline_Output, METH_O, NULL},
	 { "Fl_Multiline_Output_draw", _wrap_Fl_Multiline_Output_draw, METH_O, "Fl_Multiline_Output_draw(Fl_Multiline_Output self)"},
	 { "Fl_Multiline_Output_swigregister", Fl_Multiline_Output_swigregister, METH_O, NULL},
	 { "Fl_Multiline_Output_swiginit", Fl_Multiline_Output_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Multi_Browser", _wrap_new_Fl_Multi_Browser, METH_VARARGS, "new_Fl_Multi_Browser(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Multi_Browser"},
	 { "Fl_Multi_Browser_init_type", _wrap_Fl_Multi_Browser_init_type, METH_VARARGS, "Fl_Multi_Browser_init_type(Fl_Multi_Browser self, char * Fl_Multi_Browser)"},
	 { "delete_Fl_Multi_Browser", _wrap_delete_Fl_Multi_Browser, METH_O, "delete_Fl_Multi_Browser(Fl_Multi_Browser self)"},
	 { "disown_Fl_Multi_Browser", _wrap_disown_Fl_Multi_Browser, METH_O, NULL},
	 { "Fl_Multi_Browser_draw", _wrap_Fl_Multi_Browser_draw, METH_O, "Fl_Multi_Browser_draw(Fl_Multi_Browser self)"},
	 { "Fl_Multi_Browser_item_first", _wrap_Fl_Multi_Browser_item_first, METH_O, "Fl_Multi_Browser_item_first(Fl_Multi_Browser self) -> void *"},
	 { "Fl_Multi_Browser_item_next", _wrap_Fl_Multi_Browser_item_next, METH_VARARGS, "Fl_Multi_Browser_item_next(Fl_Multi_Browser self, void * item) -> void *"},
	 { "Fl_Multi_Browser_item_prev", _wrap_Fl_Multi_Browser_item_prev, METH_VARARGS, "Fl_Multi_Browser_item_prev(Fl_Multi_Browser self, void * item) -> void *"},
	 { "Fl_Multi_Browser_item_last", _wrap_Fl_Multi_Browser_item_last, METH_O, "Fl_Multi_Browser_item_last(Fl_Multi_Browser self) -> void *"},
	 { "Fl_Multi_Browser_item_height", _wrap_Fl_Multi_Browser_item_height, METH_VARARGS, "Fl_Multi_Browser_item_height(Fl_Multi_Browser self, void * item) -> int"},
	 { "Fl_Multi_Browser_item_width", _wrap_Fl_Multi_Browser_item_width, METH_VARARGS, "Fl_Multi_Browser_item_width(Fl_Multi_Browser self, void * item) -> int"},
	 { "Fl_Multi_Browser_item_quick_height", _wrap_Fl_Multi_Browser_item_quick_height, METH_VARARGS, "Fl_Multi_Browser_item_quick_height(Fl_Multi_Browser self, void * item) -> int"},
	 { "Fl_Multi_Browser_item_draw", _wrap_Fl_Multi_Browser_item_draw, METH_VARARGS, "Fl_Multi_Browser_item_draw(Fl_Multi_Browser self, void * item, int X, int Y, int W, int H)"},
	 { "Fl_Multi_Browser_item_text", _wrap_Fl_Multi_Browser_item_text, METH_VARARGS, "Fl_Multi_Browser_item_text(Fl_Multi_Browser self, void * item) -> char const *"},
	 { "Fl_Multi_Browser_item_swap", _wrap_Fl_Multi_Browser_item_swap, METH_VARARGS, "Fl_Multi_Browser_item_swap(Fl_Multi_Browser self, void * a, void * b)"},
	 { "Fl_Multi_Browser_item_at", _wrap_Fl_Multi_Browser_item_at, METH_VARARGS, "Fl_Multi_Browser_item_at(Fl_Multi_Browser self, int line) -> void *"},
	 { "Fl_Multi_Browser_full_width", _wrap_Fl_Multi_Browser_full_width, METH_O, "Fl_Multi_Browser_full_width(Fl_Multi_Browser self) -> int"},
	 { "Fl_Multi_Browser_full_height", _wrap_Fl_Multi_Browser_full_height, METH_O, "Fl_Multi_Browser_full_height(Fl_Multi_Browser self) -> int"},
	 { "Fl_Multi_Browser_incr_height", _wrap_Fl_Multi_Browser_incr_height, METH_O, "Fl_Multi_Browser_incr_height(Fl_Multi_Browser self) -> int"},
	 { "Fl_Multi_Browser_item_select", _wrap_Fl_Multi_Browser_item_select, METH_VARARGS, "Fl_Multi_Browser_item_select(Fl_Multi_Browser self, void * item, int val)"},
	 { "Fl_Multi_Browser_item_selected", _wrap_Fl_Multi_Browser_item_selected, METH_VARARGS, "Fl_Multi_Browser_item_selected(Fl_Multi_Browser self, void * item) -> int"},
	 { "Fl_Multi_Browser_swigregister", Fl_Multi_Browser_swigregister, METH_O, NULL},
	 { "Fl_Multi_Browser_swiginit", Fl_Multi_Browser_swiginit, METH_VARARGS, NULL},
	 { "Fl_Multi_Label_label", _wrap_Fl_Multi_Label_label, METH_VARARGS, "\n"
		"Fl_Multi_Label_label(Fl_Multi_Label self, Fl_Widget arg2)\n"
		"Fl_Multi_Label_label(Fl_Multi_Label self, Fl_Menu_Item arg2)\n"
		""},
	 { "new_Fl_Multi_Label", _wrap_new_Fl_Multi_Label, METH_NOARGS, "new_Fl_Multi_Label() -> Fl_Multi_Label"},
	 { "delete_Fl_Multi_Label", _wrap_delete_Fl_Multi_Label, METH_O, "delete_Fl_Multi_Label(Fl_Multi_Label self)"},
	 { "Fl_Multi_Label_swigregister", Fl_Multi_Label_swigregister, METH_O, NULL},
	 { "Fl_Multi_Label_swiginit", Fl_Multi_Label_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Nice_Slider", _wrap_new_Fl_Nice_Slider, METH_VARARGS, "new_Fl_Nice_Slider(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Nice_Slider"},
	 { "Fl_Nice_Slider_init_type", _wrap_Fl_Nice_Slider_init_type, METH_VARARGS, "Fl_Nice_Slider_init_type(Fl_Nice_Slider self, char * Fl_Nice_Slider)"},
	 { "delete_Fl_Nice_Slider", _wrap_delete_Fl_Nice_Slider, METH_O, "delete_Fl_Nice_Slider(Fl_Nice_Slider self)"},
	 { "disown_Fl_Nice_Slider", _wrap_disown_Fl_Nice_Slider, METH_O, NULL},
	 { "Fl_Nice_Slider_draw", _wrap_Fl_Nice_Slider_draw, METH_O, "Fl_Nice_Slider_draw(Fl_Nice_Slider self)"},
	 { "Fl_Nice_Slider_swigregister", Fl_Nice_Slider_swigregister, METH_O, NULL},
	 { "Fl_Nice_Slider_swiginit", Fl_Nice_Slider_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Native_File_Chooser", _wrap_new_Fl_Native_File_Chooser, METH_VARARGS, "new_Fl_Native_File_Chooser(int val=BROWSE_FILE) -> Fl_Native_File_Chooser"},
	 { "delete_Fl_Native_File_Chooser", _wrap_delete_Fl_Native_File_Chooser, METH_O, "delete_Fl_Native_File_Chooser(Fl_Native_File_Chooser self)"},
	 { "Fl_Native_File_Chooser_type", _wrap_Fl_Native_File_Chooser_type, METH_VARARGS, "\n"
		"Fl_Native_File_Chooser_type(Fl_Native_File_Chooser self, int t)\n"
		"Fl_Native_File_Chooser_type(Fl_Native_File_Chooser self) -> int\n"
		""},
	 { "Fl_Native_File_Chooser_options", _wrap_Fl_Native_File_Chooser_options, METH_VARARGS, "\n"
		"Fl_Native_File_Chooser_options(Fl_Native_File_Chooser self, int o)\n"
		"Fl_Native_File_Chooser_options(Fl_Native_File_Chooser self) -> int\n"
		""},
	 { "Fl_Native_File_Chooser_count", _wrap_Fl_Native_File_Chooser_count, METH_O, "Fl_Native_File_Chooser_count(Fl_Native_File_Chooser self) -> int"},
	 { "Fl_Native_File_Chooser_filename", _wrap_Fl_Native_File_Chooser_filename, METH_VARARGS, "\n"
		"Fl_Native_File_Chooser_filename(Fl_Native_File_Chooser self) -> char const\n"
		"Fl_Native_File_Chooser_filename(Fl_Native_File_Chooser self, int i) -> char const *\n"
		""},
	 { "Fl_Native_File_Chooser_directory", _wrap_Fl_Native_File_Chooser_directory, METH_VARARGS, "\n"
		"Fl_Native_File_Chooser_directory(Fl_Native_File_Chooser self, char const * val)\n"
		"Fl_Native_File_Chooser_directory(Fl_Native_File_Chooser self) -> char const *\n"
		""},
	 { "Fl_Native_File_Chooser_title", _wrap_Fl_Native_File_Chooser_title, METH_VARARGS, "\n"
		"Fl_Native_File_Chooser_title(Fl_Native_File_Chooser self, char const * t)\n"
		"Fl_Native_File_Chooser_title(Fl_Native_File_Chooser self) -> char const *\n"
		""},
	 { "Fl_Native_File_Chooser_filter", _wrap_Fl_Native_File_Chooser_filter, METH_VARARGS, "\n"
		"Fl_Native_File_Chooser_filter(Fl_Native_File_Chooser self) -> char const\n"
		"Fl_Native_File_Chooser_filter(Fl_Native_File_Chooser self, char const * f)\n"
		""},
	 { "Fl_Native_File_Chooser_filters", _wrap_Fl_Native_File_Chooser_filters, METH_O, "Fl_Native_File_Chooser_filters(Fl_Native_File_Chooser self) -> int"},
	 { "Fl_Native_File_Chooser_filter_value", _wrap_Fl_Native_File_Chooser_filter_value, METH_VARARGS, "\n"
		"Fl_Native_File_Chooser_filter_value(Fl_Native_File_Chooser self, int i)\n"
		"Fl_Native_File_Chooser_filter_value(Fl_Native_File_Chooser self) -> int\n"
		""},
	 { "Fl_Native_File_Chooser_preset_file", _wrap_Fl_Native_File_Chooser_preset_file, METH_VARARGS, "\n"
		"Fl_Native_File_Chooser_preset_file(Fl_Native_File_Chooser self, char const * f)\n"
		"Fl_Native_File_Chooser_preset_file(Fl_Native_File_Chooser self) -> char const *\n"
		""},
	 { "Fl_Native_File_Chooser_errmsg", _wrap_Fl_Native_File_Chooser_errmsg, METH_O, "Fl_Native_File_Chooser_errmsg(Fl_Native_File_Chooser self) -> char const *"},
	 { "Fl_Native_File_Chooser_show", _wrap_Fl_Native_File_Chooser_show, METH_O, "Fl_Native_File_Chooser_show(Fl_Native_File_Chooser self) -> int"},
	 { "Fl_Native_File_Chooser_swigregister", Fl_Native_File_Chooser_swigregister, METH_O, NULL},
	 { "Fl_Native_File_Chooser_swiginit", Fl_Native_File_Chooser_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Native_File_Chooser_Driver", _wrap_new_Fl_Native_File_Chooser_Driver, METH_VARARGS, "new_Fl_Native_File_Chooser_Driver(PyObject * _self, int arg2) -> Fl_Native_File_Chooser_Driver"},
	 { "delete_Fl_Native_File_Chooser_Driver", _wrap_delete_Fl_Native_File_Chooser_Driver, METH_O, "delete_Fl_Native_File_Chooser_Driver(Fl_Native_File_Chooser_Driver self)"},
	 { "Fl_Native_File_Chooser_Driver_type", _wrap_Fl_Native_File_Chooser_Driver_type, METH_VARARGS, "\n"
		"Fl_Native_File_Chooser_Driver_type(Fl_Native_File_Chooser_Driver self, int arg0)\n"
		"Fl_Native_File_Chooser_Driver_type(Fl_Native_File_Chooser_Driver self) -> int\n"
		""},
	 { "Fl_Native_File_Chooser_Driver_options", _wrap_Fl_Native_File_Chooser_Driver_options, METH_VARARGS, "\n"
		"Fl_Native_File_Chooser_Driver_options(Fl_Native_File_Chooser_Driver self, int arg0)\n"
		"Fl_Native_File_Chooser_Driver_options(Fl_Native_File_Chooser_Driver self) -> int\n"
		""},
	 { "Fl_Native_File_Chooser_Driver_count", _wrap_Fl_Native_File_Chooser_Driver_count, METH_O, "Fl_Native_File_Chooser_Driver_count(Fl_Native_File_Chooser_Driver self) -> int"},
	 { "Fl_Native_File_Chooser_Driver_filename", _wrap_Fl_Native_File_Chooser_Driver_filename, METH_VARARGS, "\n"
		"Fl_Native_File_Chooser_Driver_filename(Fl_Native_File_Chooser_Driver self) -> char const\n"
		"Fl_Native_File_Chooser_Driver_filename(Fl_Native_File_Chooser_Driver self, int arg0) -> char const *\n"
		""},
	 { "Fl_Native_File_Chooser_Driver_directory", _wrap_Fl_Native_File_Chooser_Driver_directory, METH_VARARGS, "\n"
		"Fl_Native_File_Chooser_Driver_directory(Fl_Native_File_Chooser_Driver self, char const * arg0)\n"
		"Fl_Native_File_Chooser_Driver_directory(Fl_Native_File_Chooser_Driver self) -> char const *\n"
		""},
	 { "Fl_Native_File_Chooser_Driver_title", _wrap_Fl_Native_File_Chooser_Driver_title, METH_VARARGS, "\n"
		"Fl_Native_File_Chooser_Driver_title(Fl_Native_File_Chooser_Driver self, char const * arg0)\n"
		"Fl_Native_File_Chooser_Driver_title(Fl_Native_File_Chooser_Driver self) -> char const *\n"
		""},
	 { "Fl_Native_File_Chooser_Driver_filter", _wrap_Fl_Native_File_Chooser_Driver_filter, METH_VARARGS, "\n"
		"Fl_Native_File_Chooser_Driver_filter(Fl_Native_File_Chooser_Driver self) -> char const\n"
		"Fl_Native_File_Chooser_Driver_filter(Fl_Native_File_Chooser_Driver self, char const * arg0)\n"
		""},
	 { "Fl_Native_File_Chooser_Driver_filters", _wrap_Fl_Native_File_Chooser_Driver_filters, METH_O, "Fl_Native_File_Chooser_Driver_filters(Fl_Native_File_Chooser_Driver self) -> int"},
	 { "Fl_Native_File_Chooser_Driver_filter_value", _wrap_Fl_Native_File_Chooser_Driver_filter_value, METH_VARARGS, "\n"
		"Fl_Native_File_Chooser_Driver_filter_value(Fl_Native_File_Chooser_Driver self, int arg0)\n"
		"Fl_Native_File_Chooser_Driver_filter_value(Fl_Native_File_Chooser_Driver self) -> int\n"
		""},
	 { "Fl_Native_File_Chooser_Driver_preset_file", _wrap_Fl_Native_File_Chooser_Driver_preset_file, METH_VARARGS, "\n"
		"Fl_Native_File_Chooser_Driver_preset_file(Fl_Native_File_Chooser_Driver self, char const * arg0)\n"
		"Fl_Native_File_Chooser_Driver_preset_file(Fl_Native_File_Chooser_Driver self) -> char const *\n"
		""},
	 { "Fl_Native_File_Chooser_Driver_errmsg", _wrap_Fl_Native_File_Chooser_Driver_errmsg, METH_O, "Fl_Native_File_Chooser_Driver_errmsg(Fl_Native_File_Chooser_Driver self) -> char const *"},
	 { "Fl_Native_File_Chooser_Driver_show", _wrap_Fl_Native_File_Chooser_Driver_show, METH_O, "Fl_Native_File_Chooser_Driver_show(Fl_Native_File_Chooser_Driver self) -> int"},
	 { "disown_Fl_Native_File_Chooser_Driver", _wrap_disown_Fl_Native_File_Chooser_Driver, METH_O, NULL},
	 { "Fl_Native_File_Chooser_Driver_swigregister", Fl_Native_File_Chooser_Driver_swigregister, METH_O, NULL},
	 { "Fl_Native_File_Chooser_Driver_swiginit", Fl_Native_File_Chooser_Driver_swiginit, METH_VARARGS, NULL},
	 { "Fl_Overlay_Window_draw_overlay", _wrap_Fl_Overlay_Window_draw_overlay, METH_O, "Fl_Overlay_Window_draw_overlay(Fl_Overlay_Window self)"},
	 { "Fl_Overlay_Window_hide", _wrap_Fl_Overlay_Window_hide, METH_O, "Fl_Overlay_Window_hide(Fl_Overlay_Window self)"},
	 { "Fl_Overlay_Window_flush", _wrap_Fl_Overlay_Window_flush, METH_O, "Fl_Overlay_Window_flush(Fl_Overlay_Window self)"},
	 { "Fl_Overlay_Window_resize", _wrap_Fl_Overlay_Window_resize, METH_VARARGS, "Fl_Overlay_Window_resize(Fl_Overlay_Window self, int arg0, int arg1, int arg2, int arg3)"},
	 { "delete_Fl_Overlay_Window", _wrap_delete_Fl_Overlay_Window, METH_O, "delete_Fl_Overlay_Window(Fl_Overlay_Window self)"},
	 { "Fl_Overlay_Window_can_do_overlay", _wrap_Fl_Overlay_Window_can_do_overlay, METH_O, "Fl_Overlay_Window_can_do_overlay(Fl_Overlay_Window self) -> int"},
	 { "Fl_Overlay_Window_redraw_overlay", _wrap_Fl_Overlay_Window_redraw_overlay, METH_O, "Fl_Overlay_Window_redraw_overlay(Fl_Overlay_Window self)"},
	 { "new_Fl_Overlay_Window", _wrap_new_Fl_Overlay_Window, METH_VARARGS, "\n"
		"Fl_Overlay_Window(int W, int H, char const * l=None)\n"
		"new_Fl_Overlay_Window(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Overlay_Window\n"
		""},
	 { "Fl_Overlay_Window_as_overlay_window", _wrap_Fl_Overlay_Window_as_overlay_window, METH_O, "Fl_Overlay_Window_as_overlay_window(Fl_Overlay_Window self) -> Fl_Overlay_Window"},
	 { "Fl_Overlay_Window_init_type", _wrap_Fl_Overlay_Window_init_type, METH_VARARGS, "Fl_Overlay_Window_init_type(Fl_Overlay_Window self, char * Fl_Overlay_Window)"},
	 { "Fl_Overlay_Window_show", _wrap_Fl_Overlay_Window_show, METH_VARARGS, "Fl_Overlay_Window_show(Fl_Overlay_Window self, PyObject * count=None, PyObject * data=None)"},
	 { "disown_Fl_Overlay_Window", _wrap_disown_Fl_Overlay_Window, METH_O, NULL},
	 { "Fl_Overlay_Window_draw", _wrap_Fl_Overlay_Window_draw, METH_O, "Fl_Overlay_Window_draw(Fl_Overlay_Window self)"},
	 { "Fl_Overlay_Window_swigregister", Fl_Overlay_Window_swigregister, METH_O, NULL},
	 { "Fl_Overlay_Window_swiginit", Fl_Overlay_Window_swiginit, METH_VARARGS, NULL},
	 { "Fl_Pack_draw", _wrap_Fl_Pack_draw, METH_O, "Fl_Pack_draw(Fl_Pack self)"},
	 { "new_Fl_Pack", _wrap_new_Fl_Pack, METH_VARARGS, "new_Fl_Pack(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Pack"},
	 { "Fl_Pack_spacing", _wrap_Fl_Pack_spacing, METH_VARARGS, "\n"
		"Fl_Pack_spacing(Fl_Pack self) -> int\n"
		"Fl_Pack_spacing(Fl_Pack self, int i)\n"
		""},
	 { "Fl_Pack_horizontal", _wrap_Fl_Pack_horizontal, METH_O, "Fl_Pack_horizontal(Fl_Pack self) -> uchar"},
	 { "Fl_Pack_resize", _wrap_Fl_Pack_resize, METH_VARARGS, "Fl_Pack_resize(Fl_Pack self, int X, int Y, int W, int H)"},
	 { "Fl_Pack_clear", _wrap_Fl_Pack_clear, METH_O, "Fl_Pack_clear(Fl_Pack self)"},
	 { "Fl_Pack_init_type", _wrap_Fl_Pack_init_type, METH_VARARGS, "Fl_Pack_init_type(Fl_Pack self, char * Fl_Pack)"},
	 { "delete_Fl_Pack", _wrap_delete_Fl_Pack, METH_O, "delete_Fl_Pack(Fl_Pack self)"},
	 { "disown_Fl_Pack", _wrap_disown_Fl_Pack, METH_O, NULL},
	 { "Fl_Pack_swigregister", Fl_Pack_swigregister, METH_O, NULL},
	 { "Fl_Pack_swiginit", Fl_Pack_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_PNG_Image", _wrap_new_Fl_PNG_Image, METH_VARARGS, "\n"
		"Fl_PNG_Image(char const * filename)\n"
		"new_Fl_PNG_Image(PyObject * _self, char const * name_png, unsigned char const * buffer, int datasize) -> Fl_PNG_Image\n"
		""},
	 { "delete_Fl_PNG_Image", _wrap_delete_Fl_PNG_Image, METH_O, "delete_Fl_PNG_Image(Fl_PNG_Image self)"},
	 { "disown_Fl_PNG_Image", _wrap_disown_Fl_PNG_Image, METH_O, NULL},
	 { "Fl_PNG_Image_swigregister", Fl_PNG_Image_swigregister, METH_O, NULL},
	 { "Fl_PNG_Image_swiginit", Fl_PNG_Image_swiginit, METH_VARARGS, NULL},
	 { "fl_write_png", _wrap_fl_write_png, METH_VARARGS, "\n"
		"fl_write_png(char const * filename, Fl_RGB_Image img) -> int\n"
		"fl_write_png(char const * filename, char const * pixels, int w, int h, int d=3, int ld=0) -> int\n"
		"fl_write_png(char const * filename, unsigned char const * pixels, int w, int h, int d=3, int ld=0) -> int\n"
		""},
	 { "new_Fl_PNM_Image", _wrap_new_Fl_PNM_Image, METH_VARARGS, "new_Fl_PNM_Image(PyObject * _self, char const * filename) -> Fl_PNM_Image"},
	 { "delete_Fl_PNM_Image", _wrap_delete_Fl_PNM_Image, METH_O, "delete_Fl_PNM_Image(Fl_PNM_Image self)"},
	 { "disown_Fl_PNM_Image", _wrap_disown_Fl_PNM_Image, METH_O, NULL},
	 { "Fl_PNM_Image_swigregister", Fl_PNM_Image_swigregister, METH_O, NULL},
	 { "Fl_PNM_Image_swiginit", Fl_PNM_Image_swiginit, METH_VARARGS, NULL},
	 { "Fl_Positioner_draw", _wrap_Fl_Positioner_draw, METH_O, "Fl_Positioner_draw(Fl_Positioner self)"},
	 { "Fl_Positioner_handle", _wrap_Fl_Positioner_handle, METH_VARARGS, "Fl_Positioner_handle(Fl_Positioner self, int arg0) -> int"},
	 { "new_Fl_Positioner", _wrap_new_Fl_Positioner, METH_VARARGS, "new_Fl_Positioner(PyObject * _self, int x, int y, int w, int h, char const * l=None) -> Fl_Positioner"},
	 { "Fl_Positioner_xvalue", _wrap_Fl_Positioner_xvalue, METH_VARARGS, "\n"
		"Fl_Positioner_xvalue(Fl_Positioner self) -> double\n"
		"Fl_Positioner_xvalue(Fl_Positioner self, double arg2) -> int\n"
		""},
	 { "Fl_Positioner_yvalue", _wrap_Fl_Positioner_yvalue, METH_VARARGS, "\n"
		"Fl_Positioner_yvalue(Fl_Positioner self) -> double\n"
		"Fl_Positioner_yvalue(Fl_Positioner self, double arg2) -> int\n"
		""},
	 { "Fl_Positioner_value", _wrap_Fl_Positioner_value, METH_VARARGS, "Fl_Positioner_value(Fl_Positioner self, double arg2, double arg3) -> int"},
	 { "Fl_Positioner_xbounds", _wrap_Fl_Positioner_xbounds, METH_VARARGS, "Fl_Positioner_xbounds(Fl_Positioner self, double arg2, double arg3)"},
	 { "Fl_Positioner_xminimum", _wrap_Fl_Positioner_xminimum, METH_VARARGS, "\n"
		"Fl_Positioner_xminimum(Fl_Positioner self) -> double\n"
		"Fl_Positioner_xminimum(Fl_Positioner self, double a)\n"
		""},
	 { "Fl_Positioner_xmaximum", _wrap_Fl_Positioner_xmaximum, METH_VARARGS, "\n"
		"Fl_Positioner_xmaximum(Fl_Positioner self) -> double\n"
		"Fl_Positioner_xmaximum(Fl_Positioner self, double a)\n"
		""},
	 { "Fl_Positioner_ybounds", _wrap_Fl_Positioner_ybounds, METH_VARARGS, "Fl_Positioner_ybounds(Fl_Positioner self, double arg2, double arg3)"},
	 { "Fl_Positioner_yminimum", _wrap_Fl_Positioner_yminimum, METH_VARARGS, "\n"
		"Fl_Positioner_yminimum(Fl_Positioner self) -> double\n"
		"Fl_Positioner_yminimum(Fl_Positioner self, double a)\n"
		""},
	 { "Fl_Positioner_ymaximum", _wrap_Fl_Positioner_ymaximum, METH_VARARGS, "\n"
		"Fl_Positioner_ymaximum(Fl_Positioner self) -> double\n"
		"Fl_Positioner_ymaximum(Fl_Positioner self, double a)\n"
		""},
	 { "Fl_Positioner_xstep", _wrap_Fl_Positioner_xstep, METH_VARARGS, "Fl_Positioner_xstep(Fl_Positioner self, double a)"},
	 { "Fl_Positioner_ystep", _wrap_Fl_Positioner_ystep, METH_VARARGS, "Fl_Positioner_ystep(Fl_Positioner self, double a)"},
	 { "Fl_Positioner_init_type", _wrap_Fl_Positioner_init_type, METH_VARARGS, "Fl_Positioner_init_type(Fl_Positioner self, char * Fl_Positioner)"},
	 { "delete_Fl_Positioner", _wrap_delete_Fl_Positioner, METH_O, "delete_Fl_Positioner(Fl_Positioner self)"},
	 { "disown_Fl_Positioner", _wrap_disown_Fl_Positioner, METH_O, NULL},
	 { "Fl_Positioner_swigregister", Fl_Positioner_swigregister, METH_O, NULL},
	 { "Fl_Positioner_swiginit", Fl_Positioner_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Preferences", _wrap_new_Fl_Preferences, METH_VARARGS, "\n"
		"Fl_Preferences(Fl_Preferences::Root root, char const * vendor, char const * application)\n"
		"new_Fl_Preferences(Fl_Preferences arg1, char const * group) -> Fl_Preferences\n"
		""},
	 { "delete_Fl_Preferences", _wrap_delete_Fl_Preferences, METH_O, "delete_Fl_Preferences(Fl_Preferences self)"},
	 { "Fl_Preferences_groups", _wrap_Fl_Preferences_groups, METH_O, "Fl_Preferences_groups(Fl_Preferences self) -> int"},
	 { "Fl_Preferences_group", _wrap_Fl_Preferences_group, METH_VARARGS, "Fl_Preferences_group(Fl_Preferences self, int arg2) -> char const *"},
	 { "Fl_Preferences_groupExists", _wrap_Fl_Preferences_groupExists, METH_VARARGS, "Fl_Preferences_groupExists(Fl_Preferences self, char const * group) -> char"},
	 { "Fl_Preferences_deleteGroup", _wrap_Fl_Preferences_deleteGroup, METH_VARARGS, "Fl_Preferences_deleteGroup(Fl_Preferences self, char const * group) -> char"},
	 { "Fl_Preferences_entries", _wrap_Fl_Preferences_entries, METH_O, "Fl_Preferences_entries(Fl_Preferences self) -> int"},
	 { "Fl_Preferences_entry", _wrap_Fl_Preferences_entry, METH_VARARGS, "Fl_Preferences_entry(Fl_Preferences self, int arg2) -> char const *"},
	 { "Fl_Preferences_entryExists", _wrap_Fl_Preferences_entryExists, METH_VARARGS, "Fl_Preferences_entryExists(Fl_Preferences self, char const * entry) -> char"},
	 { "Fl_Preferences_deleteEntry", _wrap_Fl_Preferences_deleteEntry, METH_VARARGS, "Fl_Preferences_deleteEntry(Fl_Preferences self, char const * entry) -> char"},
	 { "Fl_Preferences_set", _wrap_Fl_Preferences_set, METH_VARARGS, "\n"
		"Fl_Preferences_set(Fl_Preferences self, char const * entry, int value) -> char\n"
		"Fl_Preferences_set(Fl_Preferences self, char const * entry, float value, int precision) -> char\n"
		"Fl_Preferences_set(Fl_Preferences self, char const * entry, double value) -> char\n"
		"Fl_Preferences_set(Fl_Preferences self, char const * entry, double value, int precision) -> char\n"
		"Fl_Preferences_set(Fl_Preferences self, char const * entry, char const * cvalue) -> char\n"
		"Fl_Preferences_set(Fl_Preferences self, char const * entry, void const * cvalue, int size) -> char\n"
		""},
	 { "Fl_Preferences_get", _wrap_Fl_Preferences_get, METH_VARARGS, "\n"
		"Fl_Preferences_get(Fl_Preferences self, char const * entry, int defaultValue) -> char\n"
		"Fl_Preferences_get(Fl_Preferences self, char const * entry, float defaultValue) -> char\n"
		"Fl_Preferences_get(Fl_Preferences self, char const * entry, double defaultValue) -> char\n"
		"Fl_Preferences_get(Fl_Preferences self, char const * entry, char const * defaultValue, int maxSize) -> char\n"
		"Fl_Preferences_get(Fl_Preferences self, char const * entry, void * value, void const * defaultValue, int defaultSize, int maxSize) -> char\n"
		""},
	 { "Fl_Preferences_size", _wrap_Fl_Preferences_size, METH_VARARGS, "Fl_Preferences_size(Fl_Preferences self, char const * entry) -> int"},
	 { "Fl_Preferences_getUserdataPath", _wrap_Fl_Preferences_getUserdataPath, METH_VARARGS, "Fl_Preferences_getUserdataPath(Fl_Preferences self, char * path) -> char"},
	 { "Fl_Preferences_flush", _wrap_Fl_Preferences_flush, METH_O, "Fl_Preferences_flush(Fl_Preferences self)"},
	 { "Fl_Preferences_swigregister", Fl_Preferences_swigregister, METH_O, NULL},
	 { "Fl_Preferences_swiginit", Fl_Preferences_swiginit, METH_VARARGS, NULL},
	 { "Fl_Progress_draw", _wrap_Fl_Progress_draw, METH_O, "Fl_Progress_draw(Fl_Progress self)"},
	 { "new_Fl_Progress", _wrap_new_Fl_Progress, METH_VARARGS, "new_Fl_Progress(PyObject * _self, int x, int y, int w, int h, char const * l=None) -> Fl_Progress"},
	 { "Fl_Progress_maximum", _wrap_Fl_Progress_maximum, METH_VARARGS, "\n"
		"Fl_Progress_maximum(Fl_Progress self, float v)\n"
		"Fl_Progress_maximum(Fl_Progress self) -> float\n"
		""},
	 { "Fl_Progress_minimum", _wrap_Fl_Progress_minimum, METH_VARARGS, "\n"
		"Fl_Progress_minimum(Fl_Progress self, float v)\n"
		"Fl_Progress_minimum(Fl_Progress self) -> float\n"
		""},
	 { "Fl_Progress_value", _wrap_Fl_Progress_value, METH_VARARGS, "\n"
		"Fl_Progress_value(Fl_Progress self, float v)\n"
		"Fl_Progress_value(Fl_Progress self) -> float\n"
		""},
	 { "Fl_Progress_init_type", _wrap_Fl_Progress_init_type, METH_VARARGS, "Fl_Progress_init_type(Fl_Progress self, char * Fl_Progress)"},
	 { "delete_Fl_Progress", _wrap_delete_Fl_Progress, METH_O, "delete_Fl_Progress(Fl_Progress self)"},
	 { "disown_Fl_Progress", _wrap_disown_Fl_Progress, METH_O, NULL},
	 { "Fl_Progress_swigregister", Fl_Progress_swigregister, METH_O, NULL},
	 { "Fl_Progress_swiginit", Fl_Progress_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Radio_Button", _wrap_new_Fl_Radio_Button, METH_VARARGS, "new_Fl_Radio_Button(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Radio_Button"},
	 { "Fl_Radio_Button_init_type", _wrap_Fl_Radio_Button_init_type, METH_VARARGS, "Fl_Radio_Button_init_type(Fl_Radio_Button self, char * Fl_Radio_Button)"},
	 { "delete_Fl_Radio_Button", _wrap_delete_Fl_Radio_Button, METH_O, "delete_Fl_Radio_Button(Fl_Radio_Button self)"},
	 { "disown_Fl_Radio_Button", _wrap_disown_Fl_Radio_Button, METH_O, NULL},
	 { "Fl_Radio_Button_draw", _wrap_Fl_Radio_Button_draw, METH_O, "Fl_Radio_Button_draw(Fl_Radio_Button self)"},
	 { "Fl_Radio_Button_swigregister", Fl_Radio_Button_swigregister, METH_O, NULL},
	 { "Fl_Radio_Button_swiginit", Fl_Radio_Button_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Radio_Light_Button", _wrap_new_Fl_Radio_Light_Button, METH_VARARGS, "new_Fl_Radio_Light_Button(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Radio_Light_Button"},
	 { "Fl_Radio_Light_Button_init_type", _wrap_Fl_Radio_Light_Button_init_type, METH_VARARGS, "Fl_Radio_Light_Button_init_type(Fl_Radio_Light_Button self, char * Fl_Radio_Light_Button)"},
	 { "delete_Fl_Radio_Light_Button", _wrap_delete_Fl_Radio_Light_Button, METH_O, "delete_Fl_Radio_Light_Button(Fl_Radio_Light_Button self)"},
	 { "disown_Fl_Radio_Light_Button", _wrap_disown_Fl_Radio_Light_Button, METH_O, NULL},
	 { "Fl_Radio_Light_Button_draw", _wrap_Fl_Radio_Light_Button_draw, METH_O, "Fl_Radio_Light_Button_draw(Fl_Radio_Light_Button self)"},
	 { "Fl_Radio_Light_Button_swigregister", Fl_Radio_Light_Button_swigregister, METH_O, NULL},
	 { "Fl_Radio_Light_Button_swiginit", Fl_Radio_Light_Button_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Round_Button", _wrap_new_Fl_Round_Button, METH_VARARGS, "new_Fl_Round_Button(PyObject * _self, int x, int y, int w, int h, char const * l=None) -> Fl_Round_Button"},
	 { "Fl_Round_Button_init_type", _wrap_Fl_Round_Button_init_type, METH_VARARGS, "Fl_Round_Button_init_type(Fl_Round_Button self, char * Fl_Round_Button)"},
	 { "delete_Fl_Round_Button", _wrap_delete_Fl_Round_Button, METH_O, "delete_Fl_Round_Button(Fl_Round_Button self)"},
	 { "disown_Fl_Round_Button", _wrap_disown_Fl_Round_Button, METH_O, NULL},
	 { "Fl_Round_Button_draw", _wrap_Fl_Round_Button_draw, METH_O, "Fl_Round_Button_draw(Fl_Round_Button self)"},
	 { "Fl_Round_Button_swigregister", Fl_Round_Button_swigregister, METH_O, NULL},
	 { "Fl_Round_Button_swiginit", Fl_Round_Button_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Radio_Round_Button", _wrap_new_Fl_Radio_Round_Button, METH_VARARGS, "new_Fl_Radio_Round_Button(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Radio_Round_Button"},
	 { "Fl_Radio_Round_Button_init_type", _wrap_Fl_Radio_Round_Button_init_type, METH_VARARGS, "Fl_Radio_Round_Button_init_type(Fl_Radio_Round_Button self, char * Fl_Radio_Round_Button)"},
	 { "delete_Fl_Radio_Round_Button", _wrap_delete_Fl_Radio_Round_Button, METH_O, "delete_Fl_Radio_Round_Button(Fl_Radio_Round_Button self)"},
	 { "disown_Fl_Radio_Round_Button", _wrap_disown_Fl_Radio_Round_Button, METH_O, NULL},
	 { "Fl_Radio_Round_Button_draw", _wrap_Fl_Radio_Round_Button_draw, METH_O, "Fl_Radio_Round_Button_draw(Fl_Radio_Round_Button self)"},
	 { "Fl_Radio_Round_Button_swigregister", Fl_Radio_Round_Button_swigregister, METH_O, NULL},
	 { "Fl_Radio_Round_Button_swiginit", Fl_Radio_Round_Button_swiginit, METH_VARARGS, NULL},
	 { "Fl_Repeat_Button_handle", _wrap_Fl_Repeat_Button_handle, METH_VARARGS, "Fl_Repeat_Button_handle(Fl_Repeat_Button self, int arg0) -> int"},
	 { "new_Fl_Repeat_Button", _wrap_new_Fl_Repeat_Button, METH_VARARGS, "new_Fl_Repeat_Button(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Repeat_Button"},
	 { "Fl_Repeat_Button_deactivate", _wrap_Fl_Repeat_Button_deactivate, METH_O, "Fl_Repeat_Button_deactivate(Fl_Repeat_Button self)"},
	 { "Fl_Repeat_Button_init_type", _wrap_Fl_Repeat_Button_init_type, METH_VARARGS, "Fl_Repeat_Button_init_type(Fl_Repeat_Button self, char * Fl_Repeat_Button)"},
	 { "delete_Fl_Repeat_Button", _wrap_delete_Fl_Repeat_Button, METH_O, "delete_Fl_Repeat_Button(Fl_Repeat_Button self)"},
	 { "disown_Fl_Repeat_Button", _wrap_disown_Fl_Repeat_Button, METH_O, NULL},
	 { "Fl_Repeat_Button_draw", _wrap_Fl_Repeat_Button_draw, METH_O, "Fl_Repeat_Button_draw(Fl_Repeat_Button self)"},
	 { "Fl_Repeat_Button_swigregister", Fl_Repeat_Button_swigregister, METH_O, NULL},
	 { "Fl_Repeat_Button_swiginit", Fl_Repeat_Button_swiginit, METH_VARARGS, NULL},
	 { "Fl_Return_Button_draw", _wrap_Fl_Return_Button_draw, METH_O, "Fl_Return_Button_draw(Fl_Return_Button self)"},
	 { "Fl_Return_Button_handle", _wrap_Fl_Return_Button_handle, METH_VARARGS, "Fl_Return_Button_handle(Fl_Return_Button self, int arg0) -> int"},
	 { "new_Fl_Return_Button", _wrap_new_Fl_Return_Button, METH_VARARGS, "new_Fl_Return_Button(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Return_Button"},
	 { "Fl_Return_Button_init_type", _wrap_Fl_Return_Button_init_type, METH_VARARGS, "Fl_Return_Button_init_type(Fl_Return_Button self, char * Fl_Return_Button)"},
	 { "delete_Fl_Return_Button", _wrap_delete_Fl_Return_Button, METH_O, "delete_Fl_Return_Button(Fl_Return_Button self)"},
	 { "disown_Fl_Return_Button", _wrap_disown_Fl_Return_Button, METH_O, NULL},
	 { "Fl_Return_Button_swigregister", Fl_Return_Button_swigregister, METH_O, NULL},
	 { "Fl_Return_Button_swiginit", Fl_Return_Button_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Rect", _wrap_new_Fl_Rect, METH_VARARGS, "\n"
		"Fl_Rect()\n"
		"Fl_Rect(int W, int H)\n"
		"Fl_Rect(int X, int Y, int W, int H)\n"
		"Fl_Rect(int X, int Y, int W, int H, Fl_Boxtype bt)\n"
		"Fl_Rect(Fl_Widget widget)\n"
		"new_Fl_Rect(Fl_Widget widget) -> Fl_Rect\n"
		""},
	 { "Fl_Rect_x", _wrap_Fl_Rect_x, METH_VARARGS, "\n"
		"Fl_Rect_x(Fl_Rect self) -> int\n"
		"Fl_Rect_x(Fl_Rect self, int X)\n"
		""},
	 { "Fl_Rect_y", _wrap_Fl_Rect_y, METH_VARARGS, "\n"
		"Fl_Rect_y(Fl_Rect self) -> int\n"
		"Fl_Rect_y(Fl_Rect self, int Y)\n"
		""},
	 { "Fl_Rect_w", _wrap_Fl_Rect_w, METH_VARARGS, "\n"
		"Fl_Rect_w(Fl_Rect self) -> int\n"
		"Fl_Rect_w(Fl_Rect self, int W)\n"
		""},
	 { "Fl_Rect_h", _wrap_Fl_Rect_h, METH_VARARGS, "\n"
		"Fl_Rect_h(Fl_Rect self) -> int\n"
		"Fl_Rect_h(Fl_Rect self, int H)\n"
		""},
	 { "Fl_Rect_r", _wrap_Fl_Rect_r, METH_VARARGS, "\n"
		"Fl_Rect_r(Fl_Rect self) -> int\n"
		"Fl_Rect_r(Fl_Rect self, int R)\n"
		""},
	 { "Fl_Rect_b", _wrap_Fl_Rect_b, METH_VARARGS, "\n"
		"Fl_Rect_b(Fl_Rect self) -> int\n"
		"Fl_Rect_b(Fl_Rect self, int B)\n"
		""},
	 { "Fl_Rect_inset", _wrap_Fl_Rect_inset, METH_VARARGS, "\n"
		"Fl_Rect_inset(Fl_Rect self, int d)\n"
		"Fl_Rect_inset(Fl_Rect self, Fl_Boxtype bt)\n"
		"Fl_Rect_inset(Fl_Rect self, int left, int top, int right, int bottom)\n"
		""},
	 { "Fl_Rect_contains", _wrap_Fl_Rect_contains, METH_VARARGS, "Fl_Rect_contains(Fl_Rect self, int X, int Y) -> bool"},
	 { "delete_Fl_Rect", _wrap_delete_Fl_Rect, METH_O, "delete_Fl_Rect(Fl_Rect self)"},
	 { "Fl_Rect_swigregister", Fl_Rect_swigregister, METH_O, NULL},
	 { "Fl_Rect_swiginit", Fl_Rect_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_SVG_Image", _wrap_new_Fl_SVG_Image, METH_VARARGS, "\n"
		"Fl_SVG_Image(char const * filename)\n"
		"Fl_SVG_Image(char const * sharedname, char const * svg_data)\n"
		"new_Fl_SVG_Image(PyObject * _self, char const * sharedname, unsigned char const * svg_data, size_t length) -> Fl_SVG_Image\n"
		""},
	 { "delete_Fl_SVG_Image", _wrap_delete_Fl_SVG_Image, METH_O, "delete_Fl_SVG_Image(Fl_SVG_Image self)"},
	 { "Fl_SVG_Image_copy", _wrap_Fl_SVG_Image_copy, METH_VARARGS, "\n"
		"Fl_SVG_Image_copy(Fl_SVG_Image self, int W, int H) -> Fl_Image\n"
		"Fl_SVG_Image_copy(Fl_SVG_Image self) -> Fl_Image\n"
		""},
	 { "Fl_SVG_Image_resize", _wrap_Fl_SVG_Image_resize, METH_VARARGS, "Fl_SVG_Image_resize(Fl_SVG_Image self, int width, int height)"},
	 { "Fl_SVG_Image_desaturate", _wrap_Fl_SVG_Image_desaturate, METH_O, "Fl_SVG_Image_desaturate(Fl_SVG_Image self)"},
	 { "Fl_SVG_Image_color_average", _wrap_Fl_SVG_Image_color_average, METH_VARARGS, "Fl_SVG_Image_color_average(Fl_SVG_Image self, Fl_Color c, float i)"},
	 { "Fl_SVG_Image_draw", _wrap_Fl_SVG_Image_draw, METH_VARARGS, "\n"
		"Fl_SVG_Image_draw(Fl_SVG_Image self, int X, int Y, int W, int H, int cx=0, int cy=0)\n"
		"Fl_SVG_Image_draw(Fl_SVG_Image self, int X, int Y)\n"
		""},
	 { "Fl_SVG_Image_as_svg_image", _wrap_Fl_SVG_Image_as_svg_image, METH_O, "Fl_SVG_Image_as_svg_image(Fl_SVG_Image self) -> Fl_SVG_Image"},
	 { "Fl_SVG_Image_normalize", _wrap_Fl_SVG_Image_normalize, METH_O, "Fl_SVG_Image_normalize(Fl_SVG_Image self)"},
	 { "disown_Fl_SVG_Image", _wrap_disown_Fl_SVG_Image, METH_O, NULL},
	 { "Fl_SVG_Image_swigregister", Fl_SVG_Image_swigregister, METH_O, NULL},
	 { "Fl_SVG_Image_swiginit", Fl_SVG_Image_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_SVG_File_Surface", _wrap_new_Fl_SVG_File_Surface, METH_VARARGS, "new_Fl_SVG_File_Surface(int width, int height, FILE * svg, int (*)(FILE *) closef=None) -> Fl_SVG_File_Surface"},
	 { "delete_Fl_SVG_File_Surface", _wrap_delete_Fl_SVG_File_Surface, METH_O, "delete_Fl_SVG_File_Surface(Fl_SVG_File_Surface self)"},
	 { "Fl_SVG_File_Surface_file", _wrap_Fl_SVG_File_Surface_file, METH_O, "Fl_SVG_File_Surface_file(Fl_SVG_File_Surface self) -> FILE *"},
	 { "Fl_SVG_File_Surface_origin", _wrap_Fl_SVG_File_Surface_origin, METH_VARARGS, "\n"
		"Fl_SVG_File_Surface_origin(Fl_SVG_File_Surface self, int x, int y)\n"
		"Fl_SVG_File_Surface_origin(Fl_SVG_File_Surface self, int * x, int * y)\n"
		""},
	 { "Fl_SVG_File_Surface_translate", _wrap_Fl_SVG_File_Surface_translate, METH_VARARGS, "Fl_SVG_File_Surface_translate(Fl_SVG_File_Surface self, int x, int y)"},
	 { "Fl_SVG_File_Surface_untranslate", _wrap_Fl_SVG_File_Surface_untranslate, METH_O, "Fl_SVG_File_Surface_untranslate(Fl_SVG_File_Surface self)"},
	 { "Fl_SVG_File_Surface_printable_rect", _wrap_Fl_SVG_File_Surface_printable_rect, METH_VARARGS, "Fl_SVG_File_Surface_printable_rect(Fl_SVG_File_Surface self, int * w, int * h) -> int"},
	 { "Fl_SVG_File_Surface_close", _wrap_Fl_SVG_File_Surface_close, METH_O, "Fl_SVG_File_Surface_close(Fl_SVG_File_Surface self) -> int"},
	 { "Fl_SVG_File_Surface_swigregister", Fl_SVG_File_Surface_swigregister, METH_O, NULL},
	 { "Fl_SVG_File_Surface_swiginit", Fl_SVG_File_Surface_swiginit, METH_VARARGS, NULL},
	 { "Fl_Roller_draw", _wrap_Fl_Roller_draw, METH_O, "Fl_Roller_draw(Fl_Roller self)"},
	 { "Fl_Roller_handle", _wrap_Fl_Roller_handle, METH_VARARGS, "Fl_Roller_handle(Fl_Roller self, int arg0) -> int"},
	 { "new_Fl_Roller", _wrap_new_Fl_Roller, METH_VARARGS, "new_Fl_Roller(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Roller"},
	 { "Fl_Roller_init_type", _wrap_Fl_Roller_init_type, METH_VARARGS, "Fl_Roller_init_type(Fl_Roller self, char * Fl_Roller)"},
	 { "delete_Fl_Roller", _wrap_delete_Fl_Roller, METH_O, "delete_Fl_Roller(Fl_Roller self)"},
	 { "disown_Fl_Roller", _wrap_disown_Fl_Roller, METH_O, NULL},
	 { "Fl_Roller_swigregister", Fl_Roller_swigregister, METH_O, NULL},
	 { "Fl_Roller_swiginit", Fl_Roller_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Round_Clock", _wrap_new_Fl_Round_Clock, METH_VARARGS, "new_Fl_Round_Clock(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Round_Clock"},
	 { "Fl_Round_Clock_init_type", _wrap_Fl_Round_Clock_init_type, METH_VARARGS, "Fl_Round_Clock_init_type(Fl_Round_Clock self, char * Fl_Round_Clock)"},
	 { "delete_Fl_Round_Clock", _wrap_delete_Fl_Round_Clock, METH_O, "delete_Fl_Round_Clock(Fl_Round_Clock self)"},
	 { "disown_Fl_Round_Clock", _wrap_disown_Fl_Round_Clock, METH_O, NULL},
	 { "Fl_Round_Clock_draw", _wrap_Fl_Round_Clock_draw, METH_O, "Fl_Round_Clock_draw(Fl_Round_Clock self)"},
	 { "Fl_Round_Clock_swigregister", Fl_Round_Clock_swigregister, METH_O, NULL},
	 { "Fl_Round_Clock_swiginit", Fl_Round_Clock_swiginit, METH_VARARGS, NULL},
	 { "Fl_Scroll_draw", _wrap_Fl_Scroll_draw, METH_O, "Fl_Scroll_draw(Fl_Scroll self)"},
	 { "Fl_Scroll_resize", _wrap_Fl_Scroll_resize, METH_VARARGS, "Fl_Scroll_resize(Fl_Scroll self, int X, int Y, int W, int H)"},
	 { "Fl_Scroll_handle", _wrap_Fl_Scroll_handle, METH_VARARGS, "Fl_Scroll_handle(Fl_Scroll self, int arg0) -> int"},
	 { "new_Fl_Scroll", _wrap_new_Fl_Scroll, METH_VARARGS, "new_Fl_Scroll(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Scroll"},
	 { "delete_Fl_Scroll", _wrap_delete_Fl_Scroll, METH_O, "delete_Fl_Scroll(Fl_Scroll self)"},
	 { "Fl_Scroll_xposition", _wrap_Fl_Scroll_xposition, METH_O, "Fl_Scroll_xposition(Fl_Scroll self) -> int"},
	 { "Fl_Scroll_yposition", _wrap_Fl_Scroll_yposition, METH_O, "Fl_Scroll_yposition(Fl_Scroll self) -> int"},
	 { "Fl_Scroll_scroll_to", _wrap_Fl_Scroll_scroll_to, METH_VARARGS, "Fl_Scroll_scroll_to(Fl_Scroll self, int arg2, int arg3)"},
	 { "Fl_Scroll_clear", _wrap_Fl_Scroll_clear, METH_O, "Fl_Scroll_clear(Fl_Scroll self)"},
	 { "Fl_Scroll_delete_child", _wrap_Fl_Scroll_delete_child, METH_VARARGS, "Fl_Scroll_delete_child(Fl_Scroll self, int n) -> int"},
	 { "Fl_Scroll_scrollbar_size", _wrap_Fl_Scroll_scrollbar_size, METH_VARARGS, "\n"
		"Fl_Scroll_scrollbar_size(Fl_Scroll self) -> int\n"
		"Fl_Scroll_scrollbar_size(Fl_Scroll self, int newSize)\n"
		""},
	 { "Fl_Scroll_init_type", _wrap_Fl_Scroll_init_type, METH_VARARGS, "Fl_Scroll_init_type(Fl_Scroll self, char * Fl_Scroll)"},
	 { "Fl_Scroll_getScrollbar", _wrap_Fl_Scroll_getScrollbar, METH_O, "Fl_Scroll_getScrollbar(Fl_Scroll self) -> Fl_Scrollbar"},
	 { "Fl_Scroll_getHScrollbar", _wrap_Fl_Scroll_getHScrollbar, METH_O, "Fl_Scroll_getHScrollbar(Fl_Scroll self) -> Fl_Scrollbar"},
	 { "disown_Fl_Scroll", _wrap_disown_Fl_Scroll, METH_O, NULL},
	 { "Fl_Scroll_swigregister", Fl_Scroll_swigregister, METH_O, NULL},
	 { "Fl_Scroll_swiginit", Fl_Scroll_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Scheme_Choice", _wrap_new_Fl_Scheme_Choice, METH_VARARGS, "new_Fl_Scheme_Choice(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Scheme_Choice"},
	 { "Fl_Scheme_Choice_handle", _wrap_Fl_Scheme_Choice_handle, METH_VARARGS, "Fl_Scheme_Choice_handle(Fl_Scheme_Choice self, int event) -> int"},
	 { "Fl_Scheme_Choice_init_value", _wrap_Fl_Scheme_Choice_init_value, METH_O, "Fl_Scheme_Choice_init_value(Fl_Scheme_Choice self)"},
	 { "Fl_Scheme_Choice_init_type", _wrap_Fl_Scheme_Choice_init_type, METH_VARARGS, "Fl_Scheme_Choice_init_type(Fl_Scheme_Choice self, char * Fl_Scheme_Choice)"},
	 { "delete_Fl_Scheme_Choice", _wrap_delete_Fl_Scheme_Choice, METH_O, "delete_Fl_Scheme_Choice(Fl_Scheme_Choice self)"},
	 { "disown_Fl_Scheme_Choice", _wrap_disown_Fl_Scheme_Choice, METH_O, NULL},
	 { "Fl_Scheme_Choice_draw", _wrap_Fl_Scheme_Choice_draw, METH_O, "Fl_Scheme_Choice_draw(Fl_Scheme_Choice self)"},
	 { "Fl_Scheme_Choice_swigregister", Fl_Scheme_Choice_swigregister, METH_O, NULL},
	 { "Fl_Scheme_Choice_swiginit", Fl_Scheme_Choice_swiginit, METH_VARARGS, NULL},
	 { "Fl_Scrollbar_draw", _wrap_Fl_Scrollbar_draw, METH_O, "Fl_Scrollbar_draw(Fl_Scrollbar self)"},
	 { "new_Fl_Scrollbar", _wrap_new_Fl_Scrollbar, METH_VARARGS, "new_Fl_Scrollbar(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Scrollbar"},
	 { "delete_Fl_Scrollbar", _wrap_delete_Fl_Scrollbar, METH_O, "delete_Fl_Scrollbar(Fl_Scrollbar self)"},
	 { "Fl_Scrollbar_handle", _wrap_Fl_Scrollbar_handle, METH_VARARGS, "Fl_Scrollbar_handle(Fl_Scrollbar self, int arg0) -> int"},
	 { "Fl_Scrollbar_value", _wrap_Fl_Scrollbar_value, METH_VARARGS, "\n"
		"Fl_Scrollbar_value(Fl_Scrollbar self) -> int\n"
		"Fl_Scrollbar_value(Fl_Scrollbar self, int p) -> int\n"
		"Fl_Scrollbar_value(Fl_Scrollbar self, int pos, int windowSize, int first_line, int total_lines) -> int\n"
		""},
	 { "Fl_Scrollbar_linesize", _wrap_Fl_Scrollbar_linesize, METH_VARARGS, "\n"
		"Fl_Scrollbar_linesize(Fl_Scrollbar self) -> int\n"
		"Fl_Scrollbar_linesize(Fl_Scrollbar self, int i)\n"
		""},
	 { "Fl_Scrollbar_init_type", _wrap_Fl_Scrollbar_init_type, METH_VARARGS, "Fl_Scrollbar_init_type(Fl_Scrollbar self, char * Fl_Scrollbar)"},
	 { "disown_Fl_Scrollbar", _wrap_disown_Fl_Scrollbar, METH_O, NULL},
	 { "Fl_Scrollbar_swigregister", Fl_Scrollbar_swigregister, METH_O, NULL},
	 { "Fl_Scrollbar_swiginit", Fl_Scrollbar_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Secret_Input", _wrap_new_Fl_Secret_Input, METH_VARARGS, "new_Fl_Secret_Input(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Secret_Input"},
	 { "Fl_Secret_Input_handle", _wrap_Fl_Secret_Input_handle, METH_VARARGS, "Fl_Secret_Input_handle(Fl_Secret_Input self, int arg0) -> int"},
	 { "Fl_Secret_Input_init_type", _wrap_Fl_Secret_Input_init_type, METH_VARARGS, "Fl_Secret_Input_init_type(Fl_Secret_Input self, char * Fl_Secret_Input)"},
	 { "delete_Fl_Secret_Input", _wrap_delete_Fl_Secret_Input, METH_O, "delete_Fl_Secret_Input(Fl_Secret_Input self)"},
	 { "disown_Fl_Secret_Input", _wrap_disown_Fl_Secret_Input, METH_O, NULL},
	 { "Fl_Secret_Input_draw", _wrap_Fl_Secret_Input_draw, METH_O, "Fl_Secret_Input_draw(Fl_Secret_Input self)"},
	 { "Fl_Secret_Input_swigregister", Fl_Secret_Input_swigregister, METH_O, NULL},
	 { "Fl_Secret_Input_swiginit", Fl_Secret_Input_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Select_Browser", _wrap_new_Fl_Select_Browser, METH_VARARGS, "new_Fl_Select_Browser(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Select_Browser"},
	 { "Fl_Select_Browser_init_type", _wrap_Fl_Select_Browser_init_type, METH_VARARGS, "Fl_Select_Browser_init_type(Fl_Select_Browser self, char * Fl_Select_Browser)"},
	 { "delete_Fl_Select_Browser", _wrap_delete_Fl_Select_Browser, METH_O, "delete_Fl_Select_Browser(Fl_Select_Browser self)"},
	 { "disown_Fl_Select_Browser", _wrap_disown_Fl_Select_Browser, METH_O, NULL},
	 { "Fl_Select_Browser_draw", _wrap_Fl_Select_Browser_draw, METH_O, "Fl_Select_Browser_draw(Fl_Select_Browser self)"},
	 { "Fl_Select_Browser_item_first", _wrap_Fl_Select_Browser_item_first, METH_O, "Fl_Select_Browser_item_first(Fl_Select_Browser self) -> void *"},
	 { "Fl_Select_Browser_item_next", _wrap_Fl_Select_Browser_item_next, METH_VARARGS, "Fl_Select_Browser_item_next(Fl_Select_Browser self, void * item) -> void *"},
	 { "Fl_Select_Browser_item_prev", _wrap_Fl_Select_Browser_item_prev, METH_VARARGS, "Fl_Select_Browser_item_prev(Fl_Select_Browser self, void * item) -> void *"},
	 { "Fl_Select_Browser_item_last", _wrap_Fl_Select_Browser_item_last, METH_O, "Fl_Select_Browser_item_last(Fl_Select_Browser self) -> void *"},
	 { "Fl_Select_Browser_item_height", _wrap_Fl_Select_Browser_item_height, METH_VARARGS, "Fl_Select_Browser_item_height(Fl_Select_Browser self, void * item) -> int"},
	 { "Fl_Select_Browser_item_width", _wrap_Fl_Select_Browser_item_width, METH_VARARGS, "Fl_Select_Browser_item_width(Fl_Select_Browser self, void * item) -> int"},
	 { "Fl_Select_Browser_item_quick_height", _wrap_Fl_Select_Browser_item_quick_height, METH_VARARGS, "Fl_Select_Browser_item_quick_height(Fl_Select_Browser self, void * item) -> int"},
	 { "Fl_Select_Browser_item_draw", _wrap_Fl_Select_Browser_item_draw, METH_VARARGS, "Fl_Select_Browser_item_draw(Fl_Select_Browser self, void * item, int X, int Y, int W, int H)"},
	 { "Fl_Select_Browser_item_text", _wrap_Fl_Select_Browser_item_text, METH_VARARGS, "Fl_Select_Browser_item_text(Fl_Select_Browser self, void * item) -> char const *"},
	 { "Fl_Select_Browser_item_swap", _wrap_Fl_Select_Browser_item_swap, METH_VARARGS, "Fl_Select_Browser_item_swap(Fl_Select_Browser self, void * a, void * b)"},
	 { "Fl_Select_Browser_item_at", _wrap_Fl_Select_Browser_item_at, METH_VARARGS, "Fl_Select_Browser_item_at(Fl_Select_Browser self, int line) -> void *"},
	 { "Fl_Select_Browser_full_width", _wrap_Fl_Select_Browser_full_width, METH_O, "Fl_Select_Browser_full_width(Fl_Select_Browser self) -> int"},
	 { "Fl_Select_Browser_full_height", _wrap_Fl_Select_Browser_full_height, METH_O, "Fl_Select_Browser_full_height(Fl_Select_Browser self) -> int"},
	 { "Fl_Select_Browser_incr_height", _wrap_Fl_Select_Browser_incr_height, METH_O, "Fl_Select_Browser_incr_height(Fl_Select_Browser self) -> int"},
	 { "Fl_Select_Browser_item_select", _wrap_Fl_Select_Browser_item_select, METH_VARARGS, "Fl_Select_Browser_item_select(Fl_Select_Browser self, void * item, int val)"},
	 { "Fl_Select_Browser_item_selected", _wrap_Fl_Select_Browser_item_selected, METH_VARARGS, "Fl_Select_Browser_item_selected(Fl_Select_Browser self, void * item) -> int"},
	 { "Fl_Select_Browser_swigregister", Fl_Select_Browser_swigregister, METH_O, NULL},
	 { "Fl_Select_Browser_swiginit", Fl_Select_Browser_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Shared_Image", _wrap_new_Fl_Shared_Image, METH_VARARGS, "\n"
		"Fl_Shared_Image()\n"
		"new_Fl_Shared_Image(PyObject * _self, char const * n, Fl_Image img=None) -> Fl_Shared_Image\n"
		""},
	 { "Fl_Shared_Image_name", _wrap_Fl_Shared_Image_name, METH_O, "Fl_Shared_Image_name(Fl_Shared_Image self) -> char const *"},
	 { "Fl_Shared_Image_refcount", _wrap_Fl_Shared_Image_refcount, METH_O, "Fl_Shared_Image_refcount(Fl_Shared_Image self) -> int"},
	 { "Fl_Shared_Image_original", _wrap_Fl_Shared_Image_original, METH_O, "Fl_Shared_Image_original(Fl_Shared_Image self) -> int"},
	 { "Fl_Shared_Image_release", _wrap_Fl_Shared_Image_release, METH_O, "Fl_Shared_Image_release(Fl_Shared_Image self)"},
	 { "Fl_Shared_Image_reload", _wrap_Fl_Shared_Image_reload, METH_O, "Fl_Shared_Image_reload(Fl_Shared_Image self)"},
	 { "Fl_Shared_Image_as_shared_image", _wrap_Fl_Shared_Image_as_shared_image, METH_O, "Fl_Shared_Image_as_shared_image(Fl_Shared_Image self) -> Fl_Shared_Image"},
	 { "Fl_Shared_Image_copy", _wrap_Fl_Shared_Image_copy, METH_VARARGS, "\n"
		"Fl_Shared_Image_copy(Fl_Shared_Image self, int W, int H) -> Fl_Image\n"
		"Fl_Shared_Image_copy(Fl_Shared_Image self) -> Fl_Image\n"
		"Fl_Shared_Image_copy(Fl_Shared_Image self) -> Fl_Image\n"
		""},
	 { "Fl_Shared_Image_color_average", _wrap_Fl_Shared_Image_color_average, METH_VARARGS, "Fl_Shared_Image_color_average(Fl_Shared_Image self, Fl_Color c, float i)"},
	 { "Fl_Shared_Image_desaturate", _wrap_Fl_Shared_Image_desaturate, METH_O, "Fl_Shared_Image_desaturate(Fl_Shared_Image self)"},
	 { "Fl_Shared_Image_draw", _wrap_Fl_Shared_Image_draw, METH_VARARGS, "\n"
		"Fl_Shared_Image_draw(Fl_Shared_Image self, int X, int Y, int W, int H, int cx=0, int cy=0)\n"
		"Fl_Shared_Image_draw(Fl_Shared_Image self, int X, int Y)\n"
		""},
	 { "Fl_Shared_Image_uncache", _wrap_Fl_Shared_Image_uncache, METH_O, "Fl_Shared_Image_uncache(Fl_Shared_Image self)"},
	 { "Fl_Shared_Image_find", _wrap_Fl_Shared_Image_find, METH_VARARGS, "Fl_Shared_Image_find(char const * name, int W=0, int H=0) -> Fl_Shared_Image"},
	 { "Fl_Shared_Image_get", _wrap_Fl_Shared_Image_get, METH_VARARGS, "\n"
		"Fl_Shared_Image_get(char const * name, int W=0, int H=0) -> Fl_Shared_Image\n"
		"Fl_Shared_Image_get(Fl_RGB_Image rgb, int own_it=1) -> Fl_Shared_Image\n"
		""},
	 { "Fl_Shared_Image_images", _wrap_Fl_Shared_Image_images, METH_NOARGS, "Fl_Shared_Image_images() -> Fl_Shared_Image **"},
	 { "Fl_Shared_Image_num_images", _wrap_Fl_Shared_Image_num_images, METH_NOARGS, "Fl_Shared_Image_num_images() -> int"},
	 { "Fl_Shared_Image_add_handler", _wrap_Fl_Shared_Image_add_handler, METH_O, "Fl_Shared_Image_add_handler(Fl_Shared_Handler f)"},
	 { "Fl_Shared_Image_remove_handler", _wrap_Fl_Shared_Image_remove_handler, METH_O, "Fl_Shared_Image_remove_handler(Fl_Shared_Handler f)"},
	 { "Fl_Shared_Image_image", _wrap_Fl_Shared_Image_image, METH_O, "Fl_Shared_Image_image(Fl_Shared_Image self) -> Fl_Image"},
	 { "disown_Fl_Shared_Image", _wrap_disown_Fl_Shared_Image, METH_O, NULL},
	 { "Fl_Shared_Image_swigregister", Fl_Shared_Image_swigregister, METH_O, NULL},
	 { "Fl_Shared_Image_swiginit", Fl_Shared_Image_swiginit, METH_VARARGS, NULL},
	 { "fl_register_images", _wrap_fl_register_images, METH_NOARGS, "fl_register_images()"},
	 { "Fl_Spinner_draw", _wrap_Fl_Spinner_draw, METH_O, "Fl_Spinner_draw(Fl_Spinner self)"},
	 { "new_Fl_Spinner", _wrap_new_Fl_Spinner, METH_VARARGS, "new_Fl_Spinner(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Spinner"},
	 { "Fl_Spinner_handle", _wrap_Fl_Spinner_handle, METH_VARARGS, "Fl_Spinner_handle(Fl_Spinner self, int event) -> int"},
	 { "Fl_Spinner_resize", _wrap_Fl_Spinner_resize, METH_VARARGS, "Fl_Spinner_resize(Fl_Spinner self, int X, int Y, int W, int H)"},
	 { "Fl_Spinner_format", _wrap_Fl_Spinner_format, METH_VARARGS, "\n"
		"Fl_Spinner_format(Fl_Spinner self) -> char const\n"
		"Fl_Spinner_format(Fl_Spinner self, char const * f)\n"
		""},
	 { "Fl_Spinner_range", _wrap_Fl_Spinner_range, METH_VARARGS, "Fl_Spinner_range(Fl_Spinner self, double a, double b)"},
	 { "Fl_Spinner_step", _wrap_Fl_Spinner_step, METH_VARARGS, "\n"
		"Fl_Spinner_step(Fl_Spinner self, double s)\n"
		"Fl_Spinner_step(Fl_Spinner self) -> double\n"
		""},
	 { "Fl_Spinner_wrap", _wrap_Fl_Spinner_wrap, METH_VARARGS, "\n"
		"Fl_Spinner_wrap(Fl_Spinner self, int set)\n"
		"Fl_Spinner_wrap(Fl_Spinner self) -> int\n"
		""},
	 { "Fl_Spinner_textcolor", _wrap_Fl_Spinner_textcolor, METH_VARARGS, "\n"
		"Fl_Spinner_textcolor(Fl_Spinner self) -> Fl_Color\n"
		"Fl_Spinner_textcolor(Fl_Spinner self, Fl_Color c)\n"
		""},
	 { "Fl_Spinner_textfont", _wrap_Fl_Spinner_textfont, METH_VARARGS, "\n"
		"Fl_Spinner_textfont(Fl_Spinner self) -> Fl_Font\n"
		"Fl_Spinner_textfont(Fl_Spinner self, Fl_Font f)\n"
		""},
	 { "Fl_Spinner_textsize", _wrap_Fl_Spinner_textsize, METH_VARARGS, "\n"
		"Fl_Spinner_textsize(Fl_Spinner self) -> Fl_Fontsize\n"
		"Fl_Spinner_textsize(Fl_Spinner self, Fl_Fontsize s)\n"
		""},
	 { "Fl_Spinner_type", _wrap_Fl_Spinner_type, METH_VARARGS, "\n"
		"Fl_Spinner_type(Fl_Spinner self, uchar v)\n"
		"Fl_Spinner_type(Fl_Spinner self) -> uchar\n"
		""},
	 { "Fl_Spinner_value", _wrap_Fl_Spinner_value, METH_VARARGS, "\n"
		"Fl_Spinner_value(Fl_Spinner self) -> double\n"
		"Fl_Spinner_value(Fl_Spinner self, double v)\n"
		""},
	 { "Fl_Spinner_color", _wrap_Fl_Spinner_color, METH_VARARGS, "\n"
		"Fl_Spinner_color(Fl_Spinner self, Fl_Color v)\n"
		"Fl_Spinner_color(Fl_Spinner self) -> Fl_Color\n"
		""},
	 { "Fl_Spinner_selection_color", _wrap_Fl_Spinner_selection_color, METH_VARARGS, "\n"
		"Fl_Spinner_selection_color(Fl_Spinner self, Fl_Color val)\n"
		"Fl_Spinner_selection_color(Fl_Spinner self) -> Fl_Color\n"
		""},
	 { "Fl_Spinner_maximum_size", _wrap_Fl_Spinner_maximum_size, METH_VARARGS, "\n"
		"Fl_Spinner_maximum_size(Fl_Spinner self, int m)\n"
		"Fl_Spinner_maximum_size(Fl_Spinner self) -> int\n"
		""},
	 { "Fl_Spinner_init_type", _wrap_Fl_Spinner_init_type, METH_VARARGS, "Fl_Spinner_init_type(Fl_Spinner self, char * Fl_Spinner)"},
	 { "Fl_Spinner_minimum", _wrap_Fl_Spinner_minimum, METH_VARARGS, "\n"
		"Fl_Spinner_minimum(Fl_Spinner self, double m)\n"
		"Fl_Spinner_minimum(Fl_Spinner self) -> double\n"
		""},
	 { "Fl_Spinner_maximum", _wrap_Fl_Spinner_maximum, METH_VARARGS, "\n"
		"Fl_Spinner_maximum(Fl_Spinner self, double m)\n"
		"Fl_Spinner_maximum(Fl_Spinner self) -> double\n"
		""},
	 { "delete_Fl_Spinner", _wrap_delete_Fl_Spinner, METH_O, "delete_Fl_Spinner(Fl_Spinner self)"},
	 { "disown_Fl_Spinner", _wrap_disown_Fl_Spinner, METH_O, NULL},
	 { "Fl_Spinner_swigregister", Fl_Spinner_swigregister, METH_O, NULL},
	 { "Fl_Spinner_swiginit", Fl_Spinner_swiginit, METH_VARARGS, NULL},
	 { "fl_show_colormap", _wrap_fl_show_colormap, METH_O, "fl_show_colormap(Fl_Color oldcol) -> Fl_Color"},
	 { "new_Fl_Simple_Counter", _wrap_new_Fl_Simple_Counter, METH_VARARGS, "new_Fl_Simple_Counter(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Simple_Counter"},
	 { "Fl_Simple_Counter_init_type", _wrap_Fl_Simple_Counter_init_type, METH_VARARGS, "Fl_Simple_Counter_init_type(Fl_Simple_Counter self, char * Fl_Simple_Counter)"},
	 { "delete_Fl_Simple_Counter", _wrap_delete_Fl_Simple_Counter, METH_O, "delete_Fl_Simple_Counter(Fl_Simple_Counter self)"},
	 { "disown_Fl_Simple_Counter", _wrap_disown_Fl_Simple_Counter, METH_O, NULL},
	 { "Fl_Simple_Counter_draw", _wrap_Fl_Simple_Counter_draw, METH_O, "Fl_Simple_Counter_draw(Fl_Simple_Counter self)"},
	 { "Fl_Simple_Counter_swigregister", Fl_Simple_Counter_swigregister, METH_O, NULL},
	 { "Fl_Simple_Counter_swiginit", Fl_Simple_Counter_swiginit, METH_VARARGS, NULL},
	 { "Fl_Sys_Menu_Bar_draw", _wrap_Fl_Sys_Menu_Bar_draw, METH_O, "Fl_Sys_Menu_Bar_draw(Fl_Sys_Menu_Bar self)"},
	 { "new_Fl_Sys_Menu_Bar", _wrap_new_Fl_Sys_Menu_Bar, METH_VARARGS, "new_Fl_Sys_Menu_Bar(PyObject * _self, int x, int y, int w, int h, char const * l=None) -> Fl_Sys_Menu_Bar"},
	 { "delete_Fl_Sys_Menu_Bar", _wrap_delete_Fl_Sys_Menu_Bar, METH_O, "delete_Fl_Sys_Menu_Bar(Fl_Sys_Menu_Bar self)"},
	 { "Fl_Sys_Menu_Bar_menu", _wrap_Fl_Sys_Menu_Bar_menu, METH_O, "Fl_Sys_Menu_Bar_menu(Fl_Sys_Menu_Bar self) -> Fl_Menu_Item"},
	 { "Fl_Sys_Menu_Bar_update", _wrap_Fl_Sys_Menu_Bar_update, METH_O, "Fl_Sys_Menu_Bar_update(Fl_Sys_Menu_Bar self)"},
	 { "Fl_Sys_Menu_Bar_play_menu", _wrap_Fl_Sys_Menu_Bar_play_menu, METH_VARARGS, "Fl_Sys_Menu_Bar_play_menu(Fl_Sys_Menu_Bar self, Fl_Menu_Item arg0)"},
	 { "Fl_Sys_Menu_Bar_add", _wrap_Fl_Sys_Menu_Bar_add, METH_VARARGS, "\n"
		"Fl_Sys_Menu_Bar_add(Fl_Sys_Menu_Bar self, char const * label, int shortcut, Fl_Callback * arg4, void * user_data=None, int flags=0) -> int\n"
		"Fl_Sys_Menu_Bar_add(Fl_Sys_Menu_Bar self, char const * str) -> int\n"
		""},
	 { "Fl_Sys_Menu_Bar_insert", _wrap_Fl_Sys_Menu_Bar_insert, METH_VARARGS, "\n"
		"Fl_Sys_Menu_Bar_insert(Fl_Sys_Menu_Bar self, int index, char const * label, int shortcut, Fl_Callback * cb, void * user_data=None, int flags=0) -> int\n"
		"Fl_Sys_Menu_Bar_insert(Fl_Sys_Menu_Bar self, int index, char const * label, char const * shortcut, Fl_Callback * cb, void * user_data=None, int flags=0) -> int\n"
		""},
	 { "Fl_Sys_Menu_Bar_remove", _wrap_Fl_Sys_Menu_Bar_remove, METH_VARARGS, "Fl_Sys_Menu_Bar_remove(Fl_Sys_Menu_Bar self, int n)"},
	 { "Fl_Sys_Menu_Bar_replace", _wrap_Fl_Sys_Menu_Bar_replace, METH_VARARGS, "Fl_Sys_Menu_Bar_replace(Fl_Sys_Menu_Bar self, int index, char const * name)"},
	 { "Fl_Sys_Menu_Bar_clear", _wrap_Fl_Sys_Menu_Bar_clear, METH_O, "Fl_Sys_Menu_Bar_clear(Fl_Sys_Menu_Bar self)"},
	 { "Fl_Sys_Menu_Bar_clear_submenu", _wrap_Fl_Sys_Menu_Bar_clear_submenu, METH_VARARGS, "Fl_Sys_Menu_Bar_clear_submenu(Fl_Sys_Menu_Bar self, int index) -> int"},
	 { "Fl_Sys_Menu_Bar_mode", _wrap_Fl_Sys_Menu_Bar_mode, METH_VARARGS, "\n"
		"Fl_Sys_Menu_Bar_mode(Fl_Sys_Menu_Bar self, int i, int fl)\n"
		"Fl_Sys_Menu_Bar_mode(Fl_Sys_Menu_Bar self, int i) -> int\n"
		""},
	 { "Fl_Sys_Menu_Bar_shortcut", _wrap_Fl_Sys_Menu_Bar_shortcut, METH_VARARGS, "Fl_Sys_Menu_Bar_shortcut(Fl_Sys_Menu_Bar self, int i, int s)"},
	 { "Fl_Sys_Menu_Bar_setonly", _wrap_Fl_Sys_Menu_Bar_setonly, METH_VARARGS, "Fl_Sys_Menu_Bar_setonly(Fl_Sys_Menu_Bar self, Fl_Menu_Item item)"},
	 { "Fl_Sys_Menu_Bar_about", _wrap_Fl_Sys_Menu_Bar_about, METH_VARARGS, "Fl_Sys_Menu_Bar_about(Fl_Callback * cb, void * data)"},
	 { "Fl_Sys_Menu_Bar_window_menu_style", _wrap_Fl_Sys_Menu_Bar_window_menu_style, METH_VARARGS, "\n"
		"Fl_Sys_Menu_Bar_window_menu_style() -> Fl_Sys_Menu_Bar::window_menu_style_enum\n"
		"Fl_Sys_Menu_Bar_window_menu_style(Fl_Sys_Menu_Bar::window_menu_style_enum style)\n"
		""},
	 { "Fl_Sys_Menu_Bar_create_window_menu", _wrap_Fl_Sys_Menu_Bar_create_window_menu, METH_NOARGS, "Fl_Sys_Menu_Bar_create_window_menu()"},
	 { "Fl_Sys_Menu_Bar_init_type", _wrap_Fl_Sys_Menu_Bar_init_type, METH_VARARGS, "Fl_Sys_Menu_Bar_init_type(Fl_Sys_Menu_Bar self, char * Fl_Sys_Menu_Bar)"},
	 { "disown_Fl_Sys_Menu_Bar", _wrap_disown_Fl_Sys_Menu_Bar, METH_O, NULL},
	 { "Fl_Sys_Menu_Bar_swigregister", Fl_Sys_Menu_Bar_swigregister, METH_O, NULL},
	 { "Fl_Sys_Menu_Bar_swiginit", Fl_Sys_Menu_Bar_swiginit, METH_VARARGS, NULL},
	 { "Fl_Table_handle", _wrap_Fl_Table_handle, METH_VARARGS, "Fl_Table_handle(Fl_Table self, int e) -> int"},
	 { "Fl_Table_draw_cell", _wrap_Fl_Table_draw_cell, METH_VARARGS, "Fl_Table_draw_cell(Fl_Table self, Fl_Table::TableContext context, int R=0, int C=0, int X=0, int Y=0, int W=0, int H=0)"},
	 { "Fl_Table_draw", _wrap_Fl_Table_draw, METH_O, "Fl_Table_draw(Fl_Table self)"},
	 { "new_Fl_Table", _wrap_new_Fl_Table, METH_VARARGS, "new_Fl_Table(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Table"},
	 { "delete_Fl_Table", _wrap_delete_Fl_Table, METH_O, "delete_Fl_Table(Fl_Table self)"},
	 { "Fl_Table_clear", _wrap_Fl_Table_clear, METH_O, "Fl_Table_clear(Fl_Table self)"},
	 { "Fl_Table_table_box", _wrap_Fl_Table_table_box, METH_VARARGS, "\n"
		"Fl_Table_table_box(Fl_Table self, Fl_Boxtype val)\n"
		"Fl_Table_table_box(Fl_Table self) -> Fl_Boxtype\n"
		""},
	 { "Fl_Table_rows", _wrap_Fl_Table_rows, METH_VARARGS, "\n"
		"Fl_Table_rows(Fl_Table self, int val)\n"
		"Fl_Table_rows(Fl_Table self) -> int\n"
		""},
	 { "Fl_Table_cols", _wrap_Fl_Table_cols, METH_VARARGS, "\n"
		"Fl_Table_cols(Fl_Table self, int val)\n"
		"Fl_Table_cols(Fl_Table self) -> int\n"
		""},
	 { "Fl_Table_visible_cells", _wrap_Fl_Table_visible_cells, METH_O, "Fl_Table_visible_cells(Fl_Table self)"},
	 { "Fl_Table_is_interactive_resize", _wrap_Fl_Table_is_interactive_resize, METH_O, "Fl_Table_is_interactive_resize(Fl_Table self) -> int"},
	 { "Fl_Table_row_resize", _wrap_Fl_Table_row_resize, METH_VARARGS, "\n"
		"Fl_Table_row_resize(Fl_Table self) -> int\n"
		"Fl_Table_row_resize(Fl_Table self, int flag)\n"
		""},
	 { "Fl_Table_col_resize", _wrap_Fl_Table_col_resize, METH_VARARGS, "\n"
		"Fl_Table_col_resize(Fl_Table self) -> int\n"
		"Fl_Table_col_resize(Fl_Table self, int flag)\n"
		""},
	 { "Fl_Table_col_resize_min", _wrap_Fl_Table_col_resize_min, METH_VARARGS, "\n"
		"Fl_Table_col_resize_min(Fl_Table self) -> int\n"
		"Fl_Table_col_resize_min(Fl_Table self, int val)\n"
		""},
	 { "Fl_Table_row_resize_min", _wrap_Fl_Table_row_resize_min, METH_VARARGS, "\n"
		"Fl_Table_row_resize_min(Fl_Table self) -> int\n"
		"Fl_Table_row_resize_min(Fl_Table self, int val)\n"
		""},
	 { "Fl_Table_row_header", _wrap_Fl_Table_row_header, METH_VARARGS, "\n"
		"Fl_Table_row_header(Fl_Table self) -> int\n"
		"Fl_Table_row_header(Fl_Table self, int flag)\n"
		""},
	 { "Fl_Table_col_header", _wrap_Fl_Table_col_header, METH_VARARGS, "\n"
		"Fl_Table_col_header(Fl_Table self) -> int\n"
		"Fl_Table_col_header(Fl_Table self, int flag)\n"
		""},
	 { "Fl_Table_col_header_height", _wrap_Fl_Table_col_header_height, METH_VARARGS, "\n"
		"Fl_Table_col_header_height(Fl_Table self, int height)\n"
		"Fl_Table_col_header_height(Fl_Table self) -> int\n"
		""},
	 { "Fl_Table_row_header_width", _wrap_Fl_Table_row_header_width, METH_VARARGS, "\n"
		"Fl_Table_row_header_width(Fl_Table self, int width)\n"
		"Fl_Table_row_header_width(Fl_Table self) -> int\n"
		""},
	 { "Fl_Table_row_header_color", _wrap_Fl_Table_row_header_color, METH_VARARGS, "\n"
		"Fl_Table_row_header_color(Fl_Table self, Fl_Color val)\n"
		"Fl_Table_row_header_color(Fl_Table self) -> Fl_Color\n"
		""},
	 { "Fl_Table_col_header_color", _wrap_Fl_Table_col_header_color, METH_VARARGS, "\n"
		"Fl_Table_col_header_color(Fl_Table self, Fl_Color val)\n"
		"Fl_Table_col_header_color(Fl_Table self) -> Fl_Color\n"
		""},
	 { "Fl_Table_row_height", _wrap_Fl_Table_row_height, METH_VARARGS, "\n"
		"Fl_Table_row_height(Fl_Table self, int row, int height)\n"
		"Fl_Table_row_height(Fl_Table self, int row) -> int\n"
		""},
	 { "Fl_Table_col_width", _wrap_Fl_Table_col_width, METH_VARARGS, "\n"
		"Fl_Table_col_width(Fl_Table self, int col, int width)\n"
		"Fl_Table_col_width(Fl_Table self, int col) -> int\n"
		""},
	 { "Fl_Table_row_height_all", _wrap_Fl_Table_row_height_all, METH_VARARGS, "Fl_Table_row_height_all(Fl_Table self, int height)"},
	 { "Fl_Table_col_width_all", _wrap_Fl_Table_col_width_all, METH_VARARGS, "Fl_Table_col_width_all(Fl_Table self, int width)"},
	 { "Fl_Table_row_position", _wrap_Fl_Table_row_position, METH_VARARGS, "\n"
		"Fl_Table_row_position(Fl_Table self, int row)\n"
		"Fl_Table_row_position(Fl_Table self) -> int\n"
		""},
	 { "Fl_Table_col_position", _wrap_Fl_Table_col_position, METH_VARARGS, "\n"
		"Fl_Table_col_position(Fl_Table self, int col)\n"
		"Fl_Table_col_position(Fl_Table self) -> int\n"
		""},
	 { "Fl_Table_top_row", _wrap_Fl_Table_top_row, METH_VARARGS, "\n"
		"Fl_Table_top_row(Fl_Table self, int row)\n"
		"Fl_Table_top_row(Fl_Table self) -> int\n"
		""},
	 { "Fl_Table_is_selected", _wrap_Fl_Table_is_selected, METH_VARARGS, "Fl_Table_is_selected(Fl_Table self, int r, int c) -> int"},
	 { "Fl_Table_get_selection", _wrap_Fl_Table_get_selection, METH_O, "Fl_Table_get_selection(Fl_Table self)"},
	 { "Fl_Table_set_selection", _wrap_Fl_Table_set_selection, METH_VARARGS, "Fl_Table_set_selection(Fl_Table self, int row_top, int col_left, int row_bot, int col_right)"},
	 { "Fl_Table_move_cursor", _wrap_Fl_Table_move_cursor, METH_VARARGS, "\n"
		"Fl_Table_move_cursor(Fl_Table self, int R, int C, int shiftselect) -> int\n"
		"Fl_Table_move_cursor(Fl_Table self, int R, int C) -> int\n"
		""},
	 { "Fl_Table_resize", _wrap_Fl_Table_resize, METH_VARARGS, "Fl_Table_resize(Fl_Table self, int X, int Y, int W, int H)"},
	 { "Fl_Table_init_sizes", _wrap_Fl_Table_init_sizes, METH_O, "Fl_Table_init_sizes(Fl_Table self)"},
	 { "Fl_Table_add", _wrap_Fl_Table_add, METH_VARARGS, "Fl_Table_add(Fl_Table self, Fl_Widget wgt)"},
	 { "Fl_Table_insert", _wrap_Fl_Table_insert, METH_VARARGS, "Fl_Table_insert(Fl_Table self, Fl_Widget wgt, int n)"},
	 { "Fl_Table_insert_before", _wrap_Fl_Table_insert_before, METH_VARARGS, "Fl_Table_insert_before(Fl_Table self, Fl_Widget wgt, Fl_Widget w2)"},
	 { "Fl_Table_begin", _wrap_Fl_Table_begin, METH_O, "Fl_Table_begin(Fl_Table self)"},
	 { "Fl_Table_end", _wrap_Fl_Table_end, METH_O, "Fl_Table_end(Fl_Table self)"},
	 { "Fl_Table_child", _wrap_Fl_Table_child, METH_VARARGS, "Fl_Table_child(Fl_Table self, int n) -> Fl_Widget"},
	 { "Fl_Table_children", _wrap_Fl_Table_children, METH_O, "Fl_Table_children(Fl_Table self) -> int"},
	 { "Fl_Table_find", _wrap_Fl_Table_find, METH_VARARGS, "Fl_Table_find(Fl_Table self, Fl_Widget wgt) -> int"},
	 { "Fl_Table_callback_row", _wrap_Fl_Table_callback_row, METH_O, "Fl_Table_callback_row(Fl_Table self) -> int"},
	 { "Fl_Table_callback_col", _wrap_Fl_Table_callback_col, METH_O, "Fl_Table_callback_col(Fl_Table self) -> int"},
	 { "Fl_Table_callback_context", _wrap_Fl_Table_callback_context, METH_O, "Fl_Table_callback_context(Fl_Table self) -> Fl_Table::TableContext"},
	 { "Fl_Table_do_callback", _wrap_Fl_Table_do_callback, METH_VARARGS, "Fl_Table_do_callback(Fl_Table self, Fl_Table::TableContext context, int row, int col)"},
	 { "Fl_Table_scrollbar_size", _wrap_Fl_Table_scrollbar_size, METH_VARARGS, "\n"
		"Fl_Table_scrollbar_size(Fl_Table self) -> int\n"
		"Fl_Table_scrollbar_size(Fl_Table self, int newSize)\n"
		""},
	 { "Fl_Table_tab_cell_nav", _wrap_Fl_Table_tab_cell_nav, METH_VARARGS, "\n"
		"Fl_Table_tab_cell_nav(Fl_Table self, int val)\n"
		"Fl_Table_tab_cell_nav(Fl_Table self) -> int\n"
		""},
	 { "Fl_Table_init_type", _wrap_Fl_Table_init_type, METH_VARARGS, "Fl_Table_init_type(Fl_Table self, char * Fl_Table)"},
	 { "disown_Fl_Table", _wrap_disown_Fl_Table, METH_O, NULL},
	 { "Fl_Table_swigregister", Fl_Table_swigregister, METH_O, NULL},
	 { "Fl_Table_swiginit", Fl_Table_swiginit, METH_VARARGS, NULL},
	 { "Fl_Table_Row_handle", _wrap_Fl_Table_Row_handle, METH_VARARGS, "Fl_Table_Row_handle(Fl_Table_Row self, int event) -> int"},
	 { "new_Fl_Table_Row", _wrap_new_Fl_Table_Row, METH_VARARGS, "new_Fl_Table_Row(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Table_Row"},
	 { "delete_Fl_Table_Row", _wrap_delete_Fl_Table_Row, METH_O, "delete_Fl_Table_Row(Fl_Table_Row self)"},
	 { "Fl_Table_Row_rows", _wrap_Fl_Table_Row_rows, METH_VARARGS, "\n"
		"Fl_Table_Row_rows(Fl_Table_Row self, int val)\n"
		"Fl_Table_Row_rows(Fl_Table_Row self) -> int\n"
		""},
	 { "Fl_Table_Row_type", _wrap_Fl_Table_Row_type, METH_VARARGS, "\n"
		"Fl_Table_Row_type(Fl_Table_Row self, Fl_Table_Row::TableRowSelectMode val)\n"
		"Fl_Table_Row_type(Fl_Table_Row self) -> Fl_Table_Row::TableRowSelectMode\n"
		""},
	 { "Fl_Table_Row_row_selected", _wrap_Fl_Table_Row_row_selected, METH_VARARGS, "Fl_Table_Row_row_selected(Fl_Table_Row self, int row) -> int"},
	 { "Fl_Table_Row_select_row", _wrap_Fl_Table_Row_select_row, METH_VARARGS, "Fl_Table_Row_select_row(Fl_Table_Row self, int row, int flag=1) -> int"},
	 { "Fl_Table_Row_select_all_rows", _wrap_Fl_Table_Row_select_all_rows, METH_VARARGS, "Fl_Table_Row_select_all_rows(Fl_Table_Row self, int flag=1)"},
	 { "Fl_Table_Row_clear", _wrap_Fl_Table_Row_clear, METH_O, "Fl_Table_Row_clear(Fl_Table_Row self)"},
	 { "Fl_Table_Row_init_type", _wrap_Fl_Table_Row_init_type, METH_VARARGS, "Fl_Table_Row_init_type(Fl_Table_Row self, char * Fl_Table_Row)"},
	 { "disown_Fl_Table_Row", _wrap_disown_Fl_Table_Row, METH_O, NULL},
	 { "Fl_Table_Row_draw", _wrap_Fl_Table_Row_draw, METH_O, "Fl_Table_Row_draw(Fl_Table_Row self)"},
	 { "Fl_Table_Row_draw_cell", _wrap_Fl_Table_Row_draw_cell, METH_VARARGS, "Fl_Table_Row_draw_cell(Fl_Table_Row self, Fl_Table::TableContext context, int R=0, int C=0, int X=0, int Y=0, int W=0, int H=0)"},
	 { "Fl_Table_Row_swigregister", Fl_Table_Row_swigregister, METH_O, NULL},
	 { "Fl_Table_Row_swiginit", Fl_Table_Row_swiginit, METH_VARARGS, NULL},
	 { "Fl_Tabs_redraw_tabs", _wrap_Fl_Tabs_redraw_tabs, METH_O, "Fl_Tabs_redraw_tabs(Fl_Tabs self)"},
	 { "Fl_Tabs_tab_positions", _wrap_Fl_Tabs_tab_positions, METH_O, "Fl_Tabs_tab_positions(Fl_Tabs self) -> int"},
	 { "Fl_Tabs_clear_tab_positions", _wrap_Fl_Tabs_clear_tab_positions, METH_O, "Fl_Tabs_clear_tab_positions(Fl_Tabs self)"},
	 { "Fl_Tabs_draw_tab", _wrap_Fl_Tabs_draw_tab, METH_VARARGS, "Fl_Tabs_draw_tab(Fl_Tabs self, int x1, int x2, int W, int H, Fl_Widget o, int flags, int sel)"},
	 { "Fl_Tabs_tab_height", _wrap_Fl_Tabs_tab_height, METH_O, "Fl_Tabs_tab_height(Fl_Tabs self) -> int"},
	 { "Fl_Tabs_hit_close", _wrap_Fl_Tabs_hit_close, METH_VARARGS, "Fl_Tabs_hit_close(Fl_Tabs self, Fl_Widget o, int event_x, int event_y) -> int"},
	 { "Fl_Tabs_hit_overflow_menu", _wrap_Fl_Tabs_hit_overflow_menu, METH_VARARGS, "Fl_Tabs_hit_overflow_menu(Fl_Tabs self, int event_x, int event_y) -> int"},
	 { "Fl_Tabs_hit_tabs_area", _wrap_Fl_Tabs_hit_tabs_area, METH_VARARGS, "Fl_Tabs_hit_tabs_area(Fl_Tabs self, int event_x, int event_y) -> int"},
	 { "Fl_Tabs_draw", _wrap_Fl_Tabs_draw, METH_O, "Fl_Tabs_draw(Fl_Tabs self)"},
	 { "new_Fl_Tabs", _wrap_new_Fl_Tabs, METH_VARARGS, "new_Fl_Tabs(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Tabs"},
	 { "delete_Fl_Tabs", _wrap_delete_Fl_Tabs, METH_O, "delete_Fl_Tabs(Fl_Tabs self)"},
	 { "Fl_Tabs_resize", _wrap_Fl_Tabs_resize, METH_VARARGS, "Fl_Tabs_resize(Fl_Tabs self, int arg0, int arg1, int arg2, int arg3)"},
	 { "Fl_Tabs_show", _wrap_Fl_Tabs_show, METH_O, "Fl_Tabs_show(Fl_Tabs self)"},
	 { "Fl_Tabs_handle", _wrap_Fl_Tabs_handle, METH_VARARGS, "Fl_Tabs_handle(Fl_Tabs self, int arg0) -> int"},
	 { "Fl_Tabs_value", _wrap_Fl_Tabs_value, METH_VARARGS, "\n"
		"Fl_Tabs_value(Fl_Tabs self) -> Fl_Widget\n"
		"Fl_Tabs_value(Fl_Tabs self, Fl_Widget arg2) -> int\n"
		""},
	 { "Fl_Tabs_push", _wrap_Fl_Tabs_push, METH_VARARGS, "\n"
		"Fl_Tabs_push(Fl_Tabs self) -> Fl_Widget\n"
		"Fl_Tabs_push(Fl_Tabs self, Fl_Widget arg2) -> int\n"
		""},
	 { "Fl_Tabs_which", _wrap_Fl_Tabs_which, METH_VARARGS, "Fl_Tabs_which(Fl_Tabs self, int event_x, int event_y) -> Fl_Widget"},
	 { "Fl_Tabs_client_area", _wrap_Fl_Tabs_client_area, METH_VARARGS, "Fl_Tabs_client_area(Fl_Tabs self, int tabh=0)"},
	 { "Fl_Tabs_tab_align", _wrap_Fl_Tabs_tab_align, METH_VARARGS, "\n"
		"Fl_Tabs_tab_align(Fl_Tabs self, Fl_Align a)\n"
		"Fl_Tabs_tab_align(Fl_Tabs self) -> Fl_Align\n"
		""},
	 { "Fl_Tabs_handle_overflow", _wrap_Fl_Tabs_handle_overflow, METH_VARARGS, "Fl_Tabs_handle_overflow(Fl_Tabs self, int ov)"},
	 { "Fl_Tabs_init_type", _wrap_Fl_Tabs_init_type, METH_VARARGS, "Fl_Tabs_init_type(Fl_Tabs self, char * Fl_Tabs)"},
	 { "disown_Fl_Tabs", _wrap_disown_Fl_Tabs, METH_O, NULL},
	 { "Fl_Tabs_swigregister", Fl_Tabs_swigregister, METH_O, NULL},
	 { "Fl_Tabs_swiginit", Fl_Tabs_swiginit, METH_VARARGS, NULL},
	 { "Fl_Terminal_selection_text_len", _wrap_Fl_Terminal_selection_text_len, METH_O, "Fl_Terminal_selection_text_len(Fl_Terminal self) -> int"},
	 { "Fl_Terminal_selection_text", _wrap_Fl_Terminal_selection_text, METH_O, "Fl_Terminal_selection_text(Fl_Terminal self) -> char const *"},
	 { "Fl_Terminal_clear", _wrap_Fl_Terminal_clear, METH_VARARGS, "\n"
		"Fl_Terminal_clear(Fl_Terminal self)\n"
		"Fl_Terminal_clear(Fl_Terminal self, Fl_Color val)\n"
		""},
	 { "Fl_Terminal_clear_screen", _wrap_Fl_Terminal_clear_screen, METH_VARARGS, "Fl_Terminal_clear_screen(Fl_Terminal self, bool scroll_to_hist=True)"},
	 { "Fl_Terminal_clear_screen_home", _wrap_Fl_Terminal_clear_screen_home, METH_VARARGS, "Fl_Terminal_clear_screen_home(Fl_Terminal self, bool scroll_to_hist=True)"},
	 { "Fl_Terminal_clear_history", _wrap_Fl_Terminal_clear_history, METH_O, "Fl_Terminal_clear_history(Fl_Terminal self)"},
	 { "Fl_Terminal_reset_terminal", _wrap_Fl_Terminal_reset_terminal, METH_O, "Fl_Terminal_reset_terminal(Fl_Terminal self)"},
	 { "Fl_Terminal_cursor_home", _wrap_Fl_Terminal_cursor_home, METH_O, "Fl_Terminal_cursor_home(Fl_Terminal self)"},
	 { "Fl_Terminal_cursorfgcolor", _wrap_Fl_Terminal_cursorfgcolor, METH_VARARGS, "\n"
		"Fl_Terminal_cursorfgcolor(Fl_Terminal self, Fl_Color val)\n"
		"Fl_Terminal_cursorfgcolor(Fl_Terminal self) -> Fl_Color\n"
		""},
	 { "Fl_Terminal_cursorbgcolor", _wrap_Fl_Terminal_cursorbgcolor, METH_VARARGS, "\n"
		"Fl_Terminal_cursorbgcolor(Fl_Terminal self, Fl_Color val)\n"
		"Fl_Terminal_cursorbgcolor(Fl_Terminal self) -> Fl_Color\n"
		""},
	 { "Fl_Terminal_cursor_row", _wrap_Fl_Terminal_cursor_row, METH_O, "Fl_Terminal_cursor_row(Fl_Terminal self) -> int"},
	 { "Fl_Terminal_cursor_col", _wrap_Fl_Terminal_cursor_col, METH_O, "Fl_Terminal_cursor_col(Fl_Terminal self) -> int"},
	 { "Fl_Terminal_output_translate", _wrap_Fl_Terminal_output_translate, METH_VARARGS, "\n"
		"Fl_Terminal_output_translate(Fl_Terminal self, Fl_Terminal::OutFlags val)\n"
		"Fl_Terminal_output_translate(Fl_Terminal self) -> Fl_Terminal::OutFlags\n"
		""},
	 { "Fl_Terminal_plot_char", _wrap_Fl_Terminal_plot_char, METH_VARARGS, "\n"
		"Fl_Terminal_plot_char(Fl_Terminal self, char const * text, int len, int drow, int dcol)\n"
		"Fl_Terminal_plot_char(Fl_Terminal self, char c, int drow, int dcol)\n"
		""},
	 { "Fl_Terminal_print_char", _wrap_Fl_Terminal_print_char, METH_VARARGS, "\n"
		"Fl_Terminal_print_char(Fl_Terminal self, char const * text, int len=-1)\n"
		"Fl_Terminal_print_char(Fl_Terminal self, char c)\n"
		""},
	 { "Fl_Terminal_append_utf8", _wrap_Fl_Terminal_append_utf8, METH_VARARGS, "Fl_Terminal_append_utf8(Fl_Terminal self, char const * buf, int len=-1)"},
	 { "Fl_Terminal_append_ascii", _wrap_Fl_Terminal_append_ascii, METH_VARARGS, "Fl_Terminal_append_ascii(Fl_Terminal self, char const * s)"},
	 { "Fl_Terminal_append", _wrap_Fl_Terminal_append, METH_VARARGS, "Fl_Terminal_append(Fl_Terminal self, char const * s, int len=-1)"},
	 { "Fl_Terminal_draw", _wrap_Fl_Terminal_draw, METH_O, "Fl_Terminal_draw(Fl_Terminal self)"},
	 { "Fl_Terminal_resize", _wrap_Fl_Terminal_resize, METH_VARARGS, "Fl_Terminal_resize(Fl_Terminal self, int X, int Y, int W, int H)"},
	 { "Fl_Terminal_handle", _wrap_Fl_Terminal_handle, METH_VARARGS, "Fl_Terminal_handle(Fl_Terminal self, int e) -> int"},
	 { "Fl_Terminal_text", _wrap_Fl_Terminal_text, METH_VARARGS, "Fl_Terminal_text(Fl_Terminal self, bool lines_below_cursor=False) -> char const *"},
	 { "Fl_Terminal_scrollbar_size", _wrap_Fl_Terminal_scrollbar_size, METH_VARARGS, "\n"
		"Fl_Terminal_scrollbar_size(Fl_Terminal self) -> int\n"
		"Fl_Terminal_scrollbar_size(Fl_Terminal self, int val)\n"
		""},
	 { "Fl_Terminal_scrollbar_actual_size", _wrap_Fl_Terminal_scrollbar_actual_size, METH_O, "Fl_Terminal_scrollbar_actual_size(Fl_Terminal self) -> int"},
	 { "Fl_Terminal_hscrollbar_style", _wrap_Fl_Terminal_hscrollbar_style, METH_VARARGS, "\n"
		"Fl_Terminal_hscrollbar_style(Fl_Terminal self, Fl_Terminal::ScrollbarStyle val)\n"
		"Fl_Terminal_hscrollbar_style(Fl_Terminal self) -> Fl_Terminal::ScrollbarStyle\n"
		""},
	 { "Fl_Terminal_history_rows", _wrap_Fl_Terminal_history_rows, METH_VARARGS, "\n"
		"Fl_Terminal_history_rows(Fl_Terminal self) -> int\n"
		"Fl_Terminal_history_rows(Fl_Terminal self, int val)\n"
		""},
	 { "Fl_Terminal_history_use", _wrap_Fl_Terminal_history_use, METH_O, "Fl_Terminal_history_use(Fl_Terminal self) -> int"},
	 { "Fl_Terminal_display_rows", _wrap_Fl_Terminal_display_rows, METH_VARARGS, "\n"
		"Fl_Terminal_display_rows(Fl_Terminal self) -> int\n"
		"Fl_Terminal_display_rows(Fl_Terminal self, int val)\n"
		""},
	 { "Fl_Terminal_display_columns", _wrap_Fl_Terminal_display_columns, METH_VARARGS, "\n"
		"Fl_Terminal_display_columns(Fl_Terminal self) -> int\n"
		"Fl_Terminal_display_columns(Fl_Terminal self, int val)\n"
		""},
	 { "Fl_Terminal_box", _wrap_Fl_Terminal_box, METH_VARARGS, "\n"
		"Fl_Terminal_box(Fl_Terminal self, Fl_Boxtype val)\n"
		"Fl_Terminal_box(Fl_Terminal self) -> Fl_Boxtype\n"
		""},
	 { "Fl_Terminal_margin_left", _wrap_Fl_Terminal_margin_left, METH_VARARGS, "\n"
		"Fl_Terminal_margin_left(Fl_Terminal self) -> int\n"
		"Fl_Terminal_margin_left(Fl_Terminal self, int val)\n"
		""},
	 { "Fl_Terminal_margin_right", _wrap_Fl_Terminal_margin_right, METH_VARARGS, "\n"
		"Fl_Terminal_margin_right(Fl_Terminal self) -> int\n"
		"Fl_Terminal_margin_right(Fl_Terminal self, int val)\n"
		""},
	 { "Fl_Terminal_margin_top", _wrap_Fl_Terminal_margin_top, METH_VARARGS, "\n"
		"Fl_Terminal_margin_top(Fl_Terminal self) -> int\n"
		"Fl_Terminal_margin_top(Fl_Terminal self, int val)\n"
		""},
	 { "Fl_Terminal_margin_bottom", _wrap_Fl_Terminal_margin_bottom, METH_VARARGS, "\n"
		"Fl_Terminal_margin_bottom(Fl_Terminal self) -> int\n"
		"Fl_Terminal_margin_bottom(Fl_Terminal self, int val)\n"
		""},
	 { "Fl_Terminal_textfont", _wrap_Fl_Terminal_textfont, METH_VARARGS, "\n"
		"Fl_Terminal_textfont(Fl_Terminal self, Fl_Font val)\n"
		"Fl_Terminal_textfont(Fl_Terminal self) -> Fl_Font\n"
		""},
	 { "Fl_Terminal_textsize", _wrap_Fl_Terminal_textsize, METH_VARARGS, "\n"
		"Fl_Terminal_textsize(Fl_Terminal self, Fl_Fontsize val)\n"
		"Fl_Terminal_textsize(Fl_Terminal self) -> Fl_Fontsize\n"
		""},
	 { "Fl_Terminal_color", _wrap_Fl_Terminal_color, METH_VARARGS, "\n"
		"Fl_Terminal_color(Fl_Terminal self, Fl_Color val)\n"
		"Fl_Terminal_color(Fl_Terminal self) -> Fl_Color\n"
		""},
	 { "Fl_Terminal_textcolor", _wrap_Fl_Terminal_textcolor, METH_VARARGS, "\n"
		"Fl_Terminal_textcolor(Fl_Terminal self, Fl_Color val)\n"
		"Fl_Terminal_textcolor(Fl_Terminal self) -> Fl_Color\n"
		""},
	 { "Fl_Terminal_textfgcolor", _wrap_Fl_Terminal_textfgcolor, METH_VARARGS, "\n"
		"Fl_Terminal_textfgcolor(Fl_Terminal self, Fl_Color val)\n"
		"Fl_Terminal_textfgcolor(Fl_Terminal self) -> Fl_Color\n"
		""},
	 { "Fl_Terminal_textbgcolor", _wrap_Fl_Terminal_textbgcolor, METH_VARARGS, "\n"
		"Fl_Terminal_textbgcolor(Fl_Terminal self, Fl_Color val)\n"
		"Fl_Terminal_textbgcolor(Fl_Terminal self) -> Fl_Color\n"
		""},
	 { "Fl_Terminal_textfgcolor_default", _wrap_Fl_Terminal_textfgcolor_default, METH_VARARGS, "\n"
		"Fl_Terminal_textfgcolor_default(Fl_Terminal self, Fl_Color val)\n"
		"Fl_Terminal_textfgcolor_default(Fl_Terminal self) -> Fl_Color\n"
		""},
	 { "Fl_Terminal_textbgcolor_default", _wrap_Fl_Terminal_textbgcolor_default, METH_VARARGS, "\n"
		"Fl_Terminal_textbgcolor_default(Fl_Terminal self, Fl_Color val)\n"
		"Fl_Terminal_textbgcolor_default(Fl_Terminal self) -> Fl_Color\n"
		""},
	 { "Fl_Terminal_textfgcolor_xterm", _wrap_Fl_Terminal_textfgcolor_xterm, METH_VARARGS, "Fl_Terminal_textfgcolor_xterm(Fl_Terminal self, uchar val)"},
	 { "Fl_Terminal_textbgcolor_xterm", _wrap_Fl_Terminal_textbgcolor_xterm, METH_VARARGS, "Fl_Terminal_textbgcolor_xterm(Fl_Terminal self, uchar val)"},
	 { "Fl_Terminal_selectionfgcolor", _wrap_Fl_Terminal_selectionfgcolor, METH_VARARGS, "\n"
		"Fl_Terminal_selectionfgcolor(Fl_Terminal self, Fl_Color val)\n"
		"Fl_Terminal_selectionfgcolor(Fl_Terminal self) -> Fl_Color\n"
		""},
	 { "Fl_Terminal_selectionbgcolor", _wrap_Fl_Terminal_selectionbgcolor, METH_VARARGS, "\n"
		"Fl_Terminal_selectionbgcolor(Fl_Terminal self, Fl_Color val)\n"
		"Fl_Terminal_selectionbgcolor(Fl_Terminal self) -> Fl_Color\n"
		""},
	 { "Fl_Terminal_textattrib", _wrap_Fl_Terminal_textattrib, METH_VARARGS, "\n"
		"Fl_Terminal_textattrib(Fl_Terminal self, uchar val)\n"
		"Fl_Terminal_textattrib(Fl_Terminal self) -> uchar\n"
		""},
	 { "Fl_Terminal_redraw_style", _wrap_Fl_Terminal_redraw_style, METH_VARARGS, "\n"
		"Fl_Terminal_redraw_style(Fl_Terminal self) -> Fl_Terminal::RedrawStyle\n"
		"Fl_Terminal_redraw_style(Fl_Terminal self, Fl_Terminal::RedrawStyle val)\n"
		""},
	 { "Fl_Terminal_redraw_rate", _wrap_Fl_Terminal_redraw_rate, METH_VARARGS, "\n"
		"Fl_Terminal_redraw_rate(Fl_Terminal self) -> float\n"
		"Fl_Terminal_redraw_rate(Fl_Terminal self, float val)\n"
		""},
	 { "Fl_Terminal_show_unknown", _wrap_Fl_Terminal_show_unknown, METH_VARARGS, "\n"
		"Fl_Terminal_show_unknown(Fl_Terminal self) -> bool\n"
		"Fl_Terminal_show_unknown(Fl_Terminal self, bool val)\n"
		""},
	 { "Fl_Terminal_error_char", _wrap_Fl_Terminal_error_char, METH_VARARGS, "\n"
		"Fl_Terminal_error_char(Fl_Terminal self, char const * val)\n"
		"Fl_Terminal_error_char(Fl_Terminal self) -> char const *\n"
		""},
	 { "Fl_Terminal_ansi", _wrap_Fl_Terminal_ansi, METH_VARARGS, "\n"
		"Fl_Terminal_ansi(Fl_Terminal self) -> bool\n"
		"Fl_Terminal_ansi(Fl_Terminal self, bool val)\n"
		""},
	 { "Fl_Terminal_history_lines", _wrap_Fl_Terminal_history_lines, METH_VARARGS, "\n"
		"Fl_Terminal_history_lines(Fl_Terminal self) -> int\n"
		"Fl_Terminal_history_lines(Fl_Terminal self, int val)\n"
		""},
	 { "Fl_Terminal_printf", _wrap_Fl_Terminal_printf, METH_VARARGS, "Fl_Terminal_printf(Fl_Terminal self, char const * fmt)"},
	 { "new_Fl_Terminal", _wrap_new_Fl_Terminal, METH_VARARGS, "\n"
		"Fl_Terminal(int X, int Y, int W, int H, char const * L=None)\n"
		"new_Fl_Terminal(PyObject * _self, int X, int Y, int W, int H, char const * L, int rows, int cols, int hist) -> Fl_Terminal\n"
		""},
	 { "delete_Fl_Terminal", _wrap_delete_Fl_Terminal, METH_O, "delete_Fl_Terminal(Fl_Terminal self)"},
	 { "Fl_Terminal_init_type", _wrap_Fl_Terminal_init_type, METH_VARARGS, "Fl_Terminal_init_type(Fl_Terminal self, char * Fl_Terminal)"},
	 { "disown_Fl_Terminal", _wrap_disown_Fl_Terminal, METH_O, NULL},
	 { "Fl_Terminal_swigregister", Fl_Terminal_swigregister, METH_O, NULL},
	 { "Fl_Terminal_swiginit", Fl_Terminal_swiginit, METH_VARARGS, NULL},
	 { "Fl_Text_Selection_set", _wrap_Fl_Text_Selection_set, METH_VARARGS, "Fl_Text_Selection_set(Fl_Text_Selection self, int startpos, int endpos)"},
	 { "Fl_Text_Selection_update", _wrap_Fl_Text_Selection_update, METH_VARARGS, "Fl_Text_Selection_update(Fl_Text_Selection self, int pos, int nDeleted, int nInserted)"},
	 { "Fl_Text_Selection_start", _wrap_Fl_Text_Selection_start, METH_O, "Fl_Text_Selection_start(Fl_Text_Selection self) -> int"},
	 { "Fl_Text_Selection_end", _wrap_Fl_Text_Selection_end, METH_O, "Fl_Text_Selection_end(Fl_Text_Selection self) -> int"},
	 { "Fl_Text_Selection_length", _wrap_Fl_Text_Selection_length, METH_O, "Fl_Text_Selection_length(Fl_Text_Selection self) -> int"},
	 { "Fl_Text_Selection_includes", _wrap_Fl_Text_Selection_includes, METH_VARARGS, "Fl_Text_Selection_includes(Fl_Text_Selection self, int pos) -> int"},
	 { "Fl_Text_Selection_selected", _wrap_Fl_Text_Selection_selected, METH_VARARGS, "\n"
		"Fl_Text_Selection_selected(Fl_Text_Selection self) -> bool\n"
		"Fl_Text_Selection_selected(Fl_Text_Selection self, bool b)\n"
		"Fl_Text_Selection_selected(Fl_Text_Selection self, int * startpos, int * endpos) -> int\n"
		""},
	 { "new_Fl_Text_Selection", _wrap_new_Fl_Text_Selection, METH_NOARGS, "new_Fl_Text_Selection() -> Fl_Text_Selection"},
	 { "delete_Fl_Text_Selection", _wrap_delete_Fl_Text_Selection, METH_O, "delete_Fl_Text_Selection(Fl_Text_Selection self)"},
	 { "Fl_Text_Selection_swigregister", Fl_Text_Selection_swigregister, METH_O, NULL},
	 { "Fl_Text_Selection_swiginit", Fl_Text_Selection_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Text_Buffer", _wrap_new_Fl_Text_Buffer, METH_VARARGS, "new_Fl_Text_Buffer(int requestedSize=0, int preferredGapSize=1024) -> Fl_Text_Buffer"},
	 { "delete_Fl_Text_Buffer", _wrap_delete_Fl_Text_Buffer, METH_O, "delete_Fl_Text_Buffer(Fl_Text_Buffer self)"},
	 { "Fl_Text_Buffer_length", _wrap_Fl_Text_Buffer_length, METH_O, "Fl_Text_Buffer_length(Fl_Text_Buffer self) -> int"},
	 { "Fl_Text_Buffer_text_str", _wrap_Fl_Text_Buffer_text_str, METH_O, "Fl_Text_Buffer_text_str(Fl_Text_Buffer self) -> std::string"},
	 { "Fl_Text_Buffer_text", _wrap_Fl_Text_Buffer_text, METH_VARARGS, "\n"
		"Fl_Text_Buffer_text(Fl_Text_Buffer self) -> char\n"
		"Fl_Text_Buffer_text(Fl_Text_Buffer self, char const * text)\n"
		""},
	 { "Fl_Text_Buffer_text_range", _wrap_Fl_Text_Buffer_text_range, METH_VARARGS, "Fl_Text_Buffer_text_range(Fl_Text_Buffer self, int start, int end) -> char *"},
	 { "Fl_Text_Buffer_char_at", _wrap_Fl_Text_Buffer_char_at, METH_VARARGS, "Fl_Text_Buffer_char_at(Fl_Text_Buffer self, int pos) -> unsigned int"},
	 { "Fl_Text_Buffer_byte_at", _wrap_Fl_Text_Buffer_byte_at, METH_VARARGS, "Fl_Text_Buffer_byte_at(Fl_Text_Buffer self, int pos) -> char"},
	 { "Fl_Text_Buffer_address", _wrap_Fl_Text_Buffer_address, METH_VARARGS, "\n"
		"Fl_Text_Buffer_address(Fl_Text_Buffer self, int pos) -> char const\n"
		"Fl_Text_Buffer_address(Fl_Text_Buffer self, int pos) -> char *\n"
		""},
	 { "Fl_Text_Buffer_insert", _wrap_Fl_Text_Buffer_insert, METH_VARARGS, "Fl_Text_Buffer_insert(Fl_Text_Buffer self, int pos, char const * text, int insertedLength=-1)"},
	 { "Fl_Text_Buffer_append", _wrap_Fl_Text_Buffer_append, METH_VARARGS, "Fl_Text_Buffer_append(Fl_Text_Buffer self, char const * t, int addedLength=-1)"},
	 { "Fl_Text_Buffer_printf", _wrap_Fl_Text_Buffer_printf, METH_VARARGS, "Fl_Text_Buffer_printf(Fl_Text_Buffer self, char const * fmt)"},
	 { "Fl_Text_Buffer_remove", _wrap_Fl_Text_Buffer_remove, METH_VARARGS, "Fl_Text_Buffer_remove(Fl_Text_Buffer self, int start, int end)"},
	 { "Fl_Text_Buffer_replace", _wrap_Fl_Text_Buffer_replace, METH_VARARGS, "Fl_Text_Buffer_replace(Fl_Text_Buffer self, int start, int end, char const * text, int insertedLength=-1)"},
	 { "Fl_Text_Buffer_copy", _wrap_Fl_Text_Buffer_copy, METH_VARARGS, "Fl_Text_Buffer_copy(Fl_Text_Buffer self, Fl_Text_Buffer fromBuf, int fromStart, int fromEnd, int toPos)"},
	 { "Fl_Text_Buffer_undo", _wrap_Fl_Text_Buffer_undo, METH_VARARGS, "Fl_Text_Buffer_undo(Fl_Text_Buffer self, int * cp=None) -> int"},
	 { "Fl_Text_Buffer_can_undo", _wrap_Fl_Text_Buffer_can_undo, METH_O, "Fl_Text_Buffer_can_undo(Fl_Text_Buffer self) -> bool"},
	 { "Fl_Text_Buffer_redo", _wrap_Fl_Text_Buffer_redo, METH_VARARGS, "Fl_Text_Buffer_redo(Fl_Text_Buffer self, int * cp=None) -> int"},
	 { "Fl_Text_Buffer_can_redo", _wrap_Fl_Text_Buffer_can_redo, METH_O, "Fl_Text_Buffer_can_redo(Fl_Text_Buffer self) -> bool"},
	 { "Fl_Text_Buffer_canUndo", _wrap_Fl_Text_Buffer_canUndo, METH_VARARGS, "Fl_Text_Buffer_canUndo(Fl_Text_Buffer self, char flag=1)"},
	 { "Fl_Text_Buffer_insertfile", _wrap_Fl_Text_Buffer_insertfile, METH_VARARGS, "Fl_Text_Buffer_insertfile(Fl_Text_Buffer self, char const * file, int pos, int buflen=128*1024) -> int"},
	 { "Fl_Text_Buffer_appendfile", _wrap_Fl_Text_Buffer_appendfile, METH_VARARGS, "Fl_Text_Buffer_appendfile(Fl_Text_Buffer self, char const * file, int buflen=128*1024) -> int"},
	 { "Fl_Text_Buffer_loadfile", _wrap_Fl_Text_Buffer_loadfile, METH_VARARGS, "Fl_Text_Buffer_loadfile(Fl_Text_Buffer self, char const * file, int buflen=128*1024) -> int"},
	 { "Fl_Text_Buffer_outputfile", _wrap_Fl_Text_Buffer_outputfile, METH_VARARGS, "Fl_Text_Buffer_outputfile(Fl_Text_Buffer self, char const * file, int start, int end, int buflen=128*1024) -> int"},
	 { "Fl_Text_Buffer_savefile", _wrap_Fl_Text_Buffer_savefile, METH_VARARGS, "Fl_Text_Buffer_savefile(Fl_Text_Buffer self, char const * file, int buflen=128*1024) -> int"},
	 { "Fl_Text_Buffer_tab_distance", _wrap_Fl_Text_Buffer_tab_distance, METH_VARARGS, "\n"
		"Fl_Text_Buffer_tab_distance(Fl_Text_Buffer self) -> int\n"
		"Fl_Text_Buffer_tab_distance(Fl_Text_Buffer self, int tabDist)\n"
		""},
	 { "Fl_Text_Buffer_select", _wrap_Fl_Text_Buffer_select, METH_VARARGS, "Fl_Text_Buffer_select(Fl_Text_Buffer self, int start, int end)"},
	 { "Fl_Text_Buffer_selected", _wrap_Fl_Text_Buffer_selected, METH_O, "Fl_Text_Buffer_selected(Fl_Text_Buffer self) -> int"},
	 { "Fl_Text_Buffer_unselect", _wrap_Fl_Text_Buffer_unselect, METH_O, "Fl_Text_Buffer_unselect(Fl_Text_Buffer self)"},
	 { "Fl_Text_Buffer_selection_position", _wrap_Fl_Text_Buffer_selection_position, METH_VARARGS, "Fl_Text_Buffer_selection_position(Fl_Text_Buffer self, int * start, int * end) -> int"},
	 { "Fl_Text_Buffer_selection_text", _wrap_Fl_Text_Buffer_selection_text, METH_O, "Fl_Text_Buffer_selection_text(Fl_Text_Buffer self) -> char *"},
	 { "Fl_Text_Buffer_remove_selection", _wrap_Fl_Text_Buffer_remove_selection, METH_O, "Fl_Text_Buffer_remove_selection(Fl_Text_Buffer self)"},
	 { "Fl_Text_Buffer_replace_selection", _wrap_Fl_Text_Buffer_replace_selection, METH_VARARGS, "Fl_Text_Buffer_replace_selection(Fl_Text_Buffer self, char const * text)"},
	 { "Fl_Text_Buffer_secondary_select", _wrap_Fl_Text_Buffer_secondary_select, METH_VARARGS, "Fl_Text_Buffer_secondary_select(Fl_Text_Buffer self, int start, int end)"},
	 { "Fl_Text_Buffer_secondary_selected", _wrap_Fl_Text_Buffer_secondary_selected, METH_O, "Fl_Text_Buffer_secondary_selected(Fl_Text_Buffer self) -> int"},
	 { "Fl_Text_Buffer_secondary_unselect", _wrap_Fl_Text_Buffer_secondary_unselect, METH_O, "Fl_Text_Buffer_secondary_unselect(Fl_Text_Buffer self)"},
	 { "Fl_Text_Buffer_secondary_selection_position", _wrap_Fl_Text_Buffer_secondary_selection_position, METH_VARARGS, "Fl_Text_Buffer_secondary_selection_position(Fl_Text_Buffer self, int * start, int * end) -> int"},
	 { "Fl_Text_Buffer_secondary_selection_text", _wrap_Fl_Text_Buffer_secondary_selection_text, METH_O, "Fl_Text_Buffer_secondary_selection_text(Fl_Text_Buffer self) -> char *"},
	 { "Fl_Text_Buffer_remove_secondary_selection", _wrap_Fl_Text_Buffer_remove_secondary_selection, METH_O, "Fl_Text_Buffer_remove_secondary_selection(Fl_Text_Buffer self)"},
	 { "Fl_Text_Buffer_replace_secondary_selection", _wrap_Fl_Text_Buffer_replace_secondary_selection, METH_VARARGS, "Fl_Text_Buffer_replace_secondary_selection(Fl_Text_Buffer self, char const * text)"},
	 { "Fl_Text_Buffer_highlight", _wrap_Fl_Text_Buffer_highlight, METH_VARARGS, "\n"
		"Fl_Text_Buffer_highlight(Fl_Text_Buffer self, int start, int end)\n"
		"Fl_Text_Buffer_highlight(Fl_Text_Buffer self) -> int\n"
		""},
	 { "Fl_Text_Buffer_unhighlight", _wrap_Fl_Text_Buffer_unhighlight, METH_O, "Fl_Text_Buffer_unhighlight(Fl_Text_Buffer self)"},
	 { "Fl_Text_Buffer_highlight_position", _wrap_Fl_Text_Buffer_highlight_position, METH_VARARGS, "Fl_Text_Buffer_highlight_position(Fl_Text_Buffer self, int * start, int * end) -> int"},
	 { "Fl_Text_Buffer_highlight_text", _wrap_Fl_Text_Buffer_highlight_text, METH_O, "Fl_Text_Buffer_highlight_text(Fl_Text_Buffer self) -> char *"},
	 { "Fl_Text_Buffer_call_modify_callbacks", _wrap_Fl_Text_Buffer_call_modify_callbacks, METH_O, "Fl_Text_Buffer_call_modify_callbacks(Fl_Text_Buffer self)"},
	 { "Fl_Text_Buffer_add_predelete_callback", _wrap_Fl_Text_Buffer_add_predelete_callback, METH_VARARGS, "Fl_Text_Buffer_add_predelete_callback(Fl_Text_Buffer self, Fl_Text_Predelete_Cb bufPredelCB, void * cbArg)"},
	 { "Fl_Text_Buffer_remove_predelete_callback", _wrap_Fl_Text_Buffer_remove_predelete_callback, METH_VARARGS, "Fl_Text_Buffer_remove_predelete_callback(Fl_Text_Buffer self, Fl_Text_Predelete_Cb predelCB, void * cbArg)"},
	 { "Fl_Text_Buffer_call_predelete_callbacks", _wrap_Fl_Text_Buffer_call_predelete_callbacks, METH_O, "Fl_Text_Buffer_call_predelete_callbacks(Fl_Text_Buffer self)"},
	 { "Fl_Text_Buffer_line_text", _wrap_Fl_Text_Buffer_line_text, METH_VARARGS, "Fl_Text_Buffer_line_text(Fl_Text_Buffer self, int pos) -> char *"},
	 { "Fl_Text_Buffer_line_start", _wrap_Fl_Text_Buffer_line_start, METH_VARARGS, "Fl_Text_Buffer_line_start(Fl_Text_Buffer self, int pos) -> int"},
	 { "Fl_Text_Buffer_line_end", _wrap_Fl_Text_Buffer_line_end, METH_VARARGS, "Fl_Text_Buffer_line_end(Fl_Text_Buffer self, int pos) -> int"},
	 { "Fl_Text_Buffer_word_start", _wrap_Fl_Text_Buffer_word_start, METH_VARARGS, "Fl_Text_Buffer_word_start(Fl_Text_Buffer self, int pos) -> int"},
	 { "Fl_Text_Buffer_word_end", _wrap_Fl_Text_Buffer_word_end, METH_VARARGS, "Fl_Text_Buffer_word_end(Fl_Text_Buffer self, int pos) -> int"},
	 { "Fl_Text_Buffer_count_displayed_characters", _wrap_Fl_Text_Buffer_count_displayed_characters, METH_VARARGS, "Fl_Text_Buffer_count_displayed_characters(Fl_Text_Buffer self, int lineStartPos, int targetPos) -> int"},
	 { "Fl_Text_Buffer_skip_displayed_characters", _wrap_Fl_Text_Buffer_skip_displayed_characters, METH_VARARGS, "Fl_Text_Buffer_skip_displayed_characters(Fl_Text_Buffer self, int lineStartPos, int nChars) -> int"},
	 { "Fl_Text_Buffer_count_lines", _wrap_Fl_Text_Buffer_count_lines, METH_VARARGS, "Fl_Text_Buffer_count_lines(Fl_Text_Buffer self, int startPos, int endPos) -> int"},
	 { "Fl_Text_Buffer_estimate_lines", _wrap_Fl_Text_Buffer_estimate_lines, METH_VARARGS, "Fl_Text_Buffer_estimate_lines(Fl_Text_Buffer self, int startPos, int endPos, int lineLen) -> int"},
	 { "Fl_Text_Buffer_skip_lines", _wrap_Fl_Text_Buffer_skip_lines, METH_VARARGS, "Fl_Text_Buffer_skip_lines(Fl_Text_Buffer self, int startPos, int nLines) -> int"},
	 { "Fl_Text_Buffer_rewind_lines", _wrap_Fl_Text_Buffer_rewind_lines, METH_VARARGS, "Fl_Text_Buffer_rewind_lines(Fl_Text_Buffer self, int startPos, int nLines) -> int"},
	 { "Fl_Text_Buffer_findchar_forward", _wrap_Fl_Text_Buffer_findchar_forward, METH_VARARGS, "Fl_Text_Buffer_findchar_forward(Fl_Text_Buffer self, int startPos, unsigned int searchChar) -> int"},
	 { "Fl_Text_Buffer_findchar_backward", _wrap_Fl_Text_Buffer_findchar_backward, METH_VARARGS, "Fl_Text_Buffer_findchar_backward(Fl_Text_Buffer self, int startPos, unsigned int searchChar) -> int"},
	 { "Fl_Text_Buffer_search_forward", _wrap_Fl_Text_Buffer_search_forward, METH_VARARGS, "Fl_Text_Buffer_search_forward(Fl_Text_Buffer self, int startPos, char const * searchString, int matchCase=0) -> int"},
	 { "Fl_Text_Buffer_search_backward", _wrap_Fl_Text_Buffer_search_backward, METH_VARARGS, "Fl_Text_Buffer_search_backward(Fl_Text_Buffer self, int startPos, char const * searchString, int matchCase=0) -> int"},
	 { "Fl_Text_Buffer_primary_selection", _wrap_Fl_Text_Buffer_primary_selection, METH_VARARGS, "\n"
		"Fl_Text_Buffer_primary_selection(Fl_Text_Buffer self) -> Fl_Text_Selection\n"
		"Fl_Text_Buffer_primary_selection(Fl_Text_Buffer self) -> Fl_Text_Selection\n"
		""},
	 { "Fl_Text_Buffer_secondary_selection", _wrap_Fl_Text_Buffer_secondary_selection, METH_O, "Fl_Text_Buffer_secondary_selection(Fl_Text_Buffer self) -> Fl_Text_Selection"},
	 { "Fl_Text_Buffer_highlight_selection", _wrap_Fl_Text_Buffer_highlight_selection, METH_O, "Fl_Text_Buffer_highlight_selection(Fl_Text_Buffer self) -> Fl_Text_Selection"},
	 { "Fl_Text_Buffer_prev_char", _wrap_Fl_Text_Buffer_prev_char, METH_VARARGS, "Fl_Text_Buffer_prev_char(Fl_Text_Buffer self, int ix) -> int"},
	 { "Fl_Text_Buffer_prev_char_clipped", _wrap_Fl_Text_Buffer_prev_char_clipped, METH_VARARGS, "Fl_Text_Buffer_prev_char_clipped(Fl_Text_Buffer self, int ix) -> int"},
	 { "Fl_Text_Buffer_next_char", _wrap_Fl_Text_Buffer_next_char, METH_VARARGS, "Fl_Text_Buffer_next_char(Fl_Text_Buffer self, int ix) -> int"},
	 { "Fl_Text_Buffer_next_char_clipped", _wrap_Fl_Text_Buffer_next_char_clipped, METH_VARARGS, "Fl_Text_Buffer_next_char_clipped(Fl_Text_Buffer self, int ix) -> int"},
	 { "Fl_Text_Buffer_utf8_align", _wrap_Fl_Text_Buffer_utf8_align, METH_VARARGS, "Fl_Text_Buffer_utf8_align(Fl_Text_Buffer self, int arg2) -> int"},
	 { "Fl_Text_Buffer_is_word_separator", _wrap_Fl_Text_Buffer_is_word_separator, METH_VARARGS, "Fl_Text_Buffer_is_word_separator(Fl_Text_Buffer self, int pos) -> bool"},
	 { "Fl_Text_Buffer_add_modify_callback", _wrap_Fl_Text_Buffer_add_modify_callback, METH_VARARGS, "\n"
		"Fl_Text_Buffer_add_modify_callback(Fl_Text_Buffer self, Fl_Text_Modify_Cb bufModifiedCB, void * cbArg)\n"
		"Fl_Text_Buffer_add_modify_callback(Fl_Text_Buffer self, PyObject * PyFunc, PyObject * PyTarget=None)\n"
		""},
	 { "Fl_Text_Buffer_remove_modify_callback", _wrap_Fl_Text_Buffer_remove_modify_callback, METH_VARARGS, "\n"
		"Fl_Text_Buffer_remove_modify_callback(Fl_Text_Buffer self, Fl_Text_Modify_Cb bufModifiedCB, void * cbArg)\n"
		"Fl_Text_Buffer_remove_modify_callback(Fl_Text_Buffer self, PyObject * PyFunc, PyObject * PyWidget, PyObject * PyTarget)\n"
		""},
	 { "Fl_Text_Buffer_swigregister", Fl_Text_Buffer_swigregister, METH_O, NULL},
	 { "Fl_Text_Buffer_swiginit", Fl_Text_Buffer_swiginit, METH_VARARGS, NULL},
	 { "new_Style_Table_Entry", _wrap_new_Style_Table_Entry, METH_NOARGS, "new_Style_Table_Entry() -> Style_Table_Entry"},
	 { "delete_Style_Table_Entry", _wrap_delete_Style_Table_Entry, METH_O, "delete_Style_Table_Entry(Style_Table_Entry self)"},
	 { "Style_Table_Entry_swigregister", Style_Table_Entry_swigregister, METH_O, NULL},
	 { "Style_Table_Entry_swiginit", Style_Table_Entry_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Text_Display", _wrap_new_Fl_Text_Display, METH_VARARGS, "new_Fl_Text_Display(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Text_Display"},
	 { "delete_Fl_Text_Display", _wrap_delete_Fl_Text_Display, METH_O, "delete_Fl_Text_Display(Fl_Text_Display self)"},
	 { "Fl_Text_Display_handle", _wrap_Fl_Text_Display_handle, METH_VARARGS, "Fl_Text_Display_handle(Fl_Text_Display self, int e) -> int"},
	 { "Fl_Text_Display_buffer", _wrap_Fl_Text_Display_buffer, METH_VARARGS, "\n"
		"Fl_Text_Display_buffer(Fl_Text_Display self, Fl_Text_Buffer buf)\n"
		"Fl_Text_Display_buffer(Fl_Text_Display self) -> Fl_Text_Buffer\n"
		""},
	 { "Fl_Text_Display_style_buffer", _wrap_Fl_Text_Display_style_buffer, METH_O, "Fl_Text_Display_style_buffer(Fl_Text_Display self) -> Fl_Text_Buffer"},
	 { "Fl_Text_Display_redisplay_range", _wrap_Fl_Text_Display_redisplay_range, METH_VARARGS, "Fl_Text_Display_redisplay_range(Fl_Text_Display self, int start, int end)"},
	 { "Fl_Text_Display_scroll", _wrap_Fl_Text_Display_scroll, METH_VARARGS, "Fl_Text_Display_scroll(Fl_Text_Display self, int topLineNum, int horizOffset)"},
	 { "Fl_Text_Display_insert", _wrap_Fl_Text_Display_insert, METH_VARARGS, "Fl_Text_Display_insert(Fl_Text_Display self, char const * text)"},
	 { "Fl_Text_Display_overstrike", _wrap_Fl_Text_Display_overstrike, METH_VARARGS, "Fl_Text_Display_overstrike(Fl_Text_Display self, char const * text)"},
	 { "Fl_Text_Display_insert_position", _wrap_Fl_Text_Display_insert_position, METH_VARARGS, "\n"
		"Fl_Text_Display_insert_position(Fl_Text_Display self, int newPos)\n"
		"Fl_Text_Display_insert_position(Fl_Text_Display self) -> int\n"
		""},
	 { "Fl_Text_Display_position_to_xy", _wrap_Fl_Text_Display_position_to_xy, METH_VARARGS, "Fl_Text_Display_position_to_xy(Fl_Text_Display self, int pos, int * x, int * y) -> int"},
	 { "Fl_Text_Display_in_selection", _wrap_Fl_Text_Display_in_selection, METH_VARARGS, "Fl_Text_Display_in_selection(Fl_Text_Display self, int x, int y) -> int"},
	 { "Fl_Text_Display_show_insert_position", _wrap_Fl_Text_Display_show_insert_position, METH_O, "Fl_Text_Display_show_insert_position(Fl_Text_Display self)"},
	 { "Fl_Text_Display_move_right", _wrap_Fl_Text_Display_move_right, METH_O, "Fl_Text_Display_move_right(Fl_Text_Display self) -> int"},
	 { "Fl_Text_Display_move_left", _wrap_Fl_Text_Display_move_left, METH_O, "Fl_Text_Display_move_left(Fl_Text_Display self) -> int"},
	 { "Fl_Text_Display_move_up", _wrap_Fl_Text_Display_move_up, METH_O, "Fl_Text_Display_move_up(Fl_Text_Display self) -> int"},
	 { "Fl_Text_Display_move_down", _wrap_Fl_Text_Display_move_down, METH_O, "Fl_Text_Display_move_down(Fl_Text_Display self) -> int"},
	 { "Fl_Text_Display_count_lines", _wrap_Fl_Text_Display_count_lines, METH_VARARGS, "Fl_Text_Display_count_lines(Fl_Text_Display self, int start, int end, bool start_pos_is_line_start) -> int"},
	 { "Fl_Text_Display_line_start", _wrap_Fl_Text_Display_line_start, METH_VARARGS, "Fl_Text_Display_line_start(Fl_Text_Display self, int pos) -> int"},
	 { "Fl_Text_Display_line_end", _wrap_Fl_Text_Display_line_end, METH_VARARGS, "Fl_Text_Display_line_end(Fl_Text_Display self, int startPos, bool startPosIsLineStart) -> int"},
	 { "Fl_Text_Display_skip_lines", _wrap_Fl_Text_Display_skip_lines, METH_VARARGS, "Fl_Text_Display_skip_lines(Fl_Text_Display self, int startPos, int nLines, bool startPosIsLineStart) -> int"},
	 { "Fl_Text_Display_rewind_lines", _wrap_Fl_Text_Display_rewind_lines, METH_VARARGS, "Fl_Text_Display_rewind_lines(Fl_Text_Display self, int startPos, int nLines) -> int"},
	 { "Fl_Text_Display_next_word", _wrap_Fl_Text_Display_next_word, METH_O, "Fl_Text_Display_next_word(Fl_Text_Display self)"},
	 { "Fl_Text_Display_previous_word", _wrap_Fl_Text_Display_previous_word, METH_O, "Fl_Text_Display_previous_word(Fl_Text_Display self)"},
	 { "Fl_Text_Display_show_cursor", _wrap_Fl_Text_Display_show_cursor, METH_VARARGS, "Fl_Text_Display_show_cursor(Fl_Text_Display self, int b=1)"},
	 { "Fl_Text_Display_hide_cursor", _wrap_Fl_Text_Display_hide_cursor, METH_O, "Fl_Text_Display_hide_cursor(Fl_Text_Display self)"},
	 { "Fl_Text_Display_cursor_style", _wrap_Fl_Text_Display_cursor_style, METH_VARARGS, "\n"
		"Fl_Text_Display_cursor_style(Fl_Text_Display self, int style)\n"
		"Fl_Text_Display_cursor_style(Fl_Text_Display self) -> int\n"
		""},
	 { "Fl_Text_Display_cursor_color", _wrap_Fl_Text_Display_cursor_color, METH_VARARGS, "\n"
		"Fl_Text_Display_cursor_color(Fl_Text_Display self) -> Fl_Color\n"
		"Fl_Text_Display_cursor_color(Fl_Text_Display self, Fl_Color n)\n"
		""},
	 { "Fl_Text_Display_scrollbar_width", _wrap_Fl_Text_Display_scrollbar_width, METH_VARARGS, "\n"
		"Fl_Text_Display_scrollbar_width(Fl_Text_Display self) -> int\n"
		"Fl_Text_Display_scrollbar_width(Fl_Text_Display self, int width)\n"
		""},
	 { "Fl_Text_Display_scrollbar_size", _wrap_Fl_Text_Display_scrollbar_size, METH_VARARGS, "\n"
		"Fl_Text_Display_scrollbar_size(Fl_Text_Display self) -> int\n"
		"Fl_Text_Display_scrollbar_size(Fl_Text_Display self, int newSize)\n"
		""},
	 { "Fl_Text_Display_scrollbar_align", _wrap_Fl_Text_Display_scrollbar_align, METH_VARARGS, "\n"
		"Fl_Text_Display_scrollbar_align(Fl_Text_Display self) -> Fl_Align\n"
		"Fl_Text_Display_scrollbar_align(Fl_Text_Display self, Fl_Align a)\n"
		""},
	 { "Fl_Text_Display_word_start", _wrap_Fl_Text_Display_word_start, METH_VARARGS, "Fl_Text_Display_word_start(Fl_Text_Display self, int pos) -> int"},
	 { "Fl_Text_Display_word_end", _wrap_Fl_Text_Display_word_end, METH_VARARGS, "Fl_Text_Display_word_end(Fl_Text_Display self, int pos) -> int"},
	 { "Fl_Text_Display_position_style", _wrap_Fl_Text_Display_position_style, METH_VARARGS, "Fl_Text_Display_position_style(Fl_Text_Display self, int lineStartPos, int lineLen, int lineIndex) -> int"},
	 { "Fl_Text_Display_shortcut", _wrap_Fl_Text_Display_shortcut, METH_VARARGS, "\n"
		"Fl_Text_Display_shortcut(Fl_Text_Display self) -> int\n"
		"Fl_Text_Display_shortcut(Fl_Text_Display self, int s)\n"
		""},
	 { "Fl_Text_Display_textfont", _wrap_Fl_Text_Display_textfont, METH_VARARGS, "\n"
		"Fl_Text_Display_textfont(Fl_Text_Display self) -> Fl_Font\n"
		"Fl_Text_Display_textfont(Fl_Text_Display self, Fl_Font s)\n"
		""},
	 { "Fl_Text_Display_textsize", _wrap_Fl_Text_Display_textsize, METH_VARARGS, "\n"
		"Fl_Text_Display_textsize(Fl_Text_Display self) -> Fl_Fontsize\n"
		"Fl_Text_Display_textsize(Fl_Text_Display self, Fl_Fontsize s)\n"
		""},
	 { "Fl_Text_Display_textcolor", _wrap_Fl_Text_Display_textcolor, METH_VARARGS, "\n"
		"Fl_Text_Display_textcolor(Fl_Text_Display self) -> Fl_Color\n"
		"Fl_Text_Display_textcolor(Fl_Text_Display self, Fl_Color n)\n"
		""},
	 { "Fl_Text_Display_grammar_underline_color", _wrap_Fl_Text_Display_grammar_underline_color, METH_VARARGS, "\n"
		"Fl_Text_Display_grammar_underline_color(Fl_Text_Display self, Fl_Color color)\n"
		"Fl_Text_Display_grammar_underline_color(Fl_Text_Display self) -> Fl_Color\n"
		""},
	 { "Fl_Text_Display_spelling_underline_color", _wrap_Fl_Text_Display_spelling_underline_color, METH_VARARGS, "\n"
		"Fl_Text_Display_spelling_underline_color(Fl_Text_Display self, Fl_Color color)\n"
		"Fl_Text_Display_spelling_underline_color(Fl_Text_Display self) -> Fl_Color\n"
		""},
	 { "Fl_Text_Display_secondary_selection_color", _wrap_Fl_Text_Display_secondary_selection_color, METH_VARARGS, "\n"
		"Fl_Text_Display_secondary_selection_color(Fl_Text_Display self, Fl_Color color)\n"
		"Fl_Text_Display_secondary_selection_color(Fl_Text_Display self) -> Fl_Color\n"
		""},
	 { "Fl_Text_Display_wrapped_column", _wrap_Fl_Text_Display_wrapped_column, METH_VARARGS, "Fl_Text_Display_wrapped_column(Fl_Text_Display self, int row, int column) -> int"},
	 { "Fl_Text_Display_wrapped_row", _wrap_Fl_Text_Display_wrapped_row, METH_VARARGS, "Fl_Text_Display_wrapped_row(Fl_Text_Display self, int row) -> int"},
	 { "Fl_Text_Display_wrap_mode", _wrap_Fl_Text_Display_wrap_mode, METH_VARARGS, "Fl_Text_Display_wrap_mode(Fl_Text_Display self, int wrap, int wrap_margin)"},
	 { "Fl_Text_Display_recalc_display", _wrap_Fl_Text_Display_recalc_display, METH_O, "Fl_Text_Display_recalc_display(Fl_Text_Display self)"},
	 { "Fl_Text_Display_display_needs_recalc", _wrap_Fl_Text_Display_display_needs_recalc, METH_O, "Fl_Text_Display_display_needs_recalc(Fl_Text_Display self)"},
	 { "Fl_Text_Display_resize", _wrap_Fl_Text_Display_resize, METH_VARARGS, "Fl_Text_Display_resize(Fl_Text_Display self, int X, int Y, int W, int H)"},
	 { "Fl_Text_Display_x_to_col", _wrap_Fl_Text_Display_x_to_col, METH_VARARGS, "Fl_Text_Display_x_to_col(Fl_Text_Display self, double x) -> double"},
	 { "Fl_Text_Display_col_to_x", _wrap_Fl_Text_Display_col_to_x, METH_VARARGS, "Fl_Text_Display_col_to_x(Fl_Text_Display self, double col) -> double"},
	 { "Fl_Text_Display_linenumber_width", _wrap_Fl_Text_Display_linenumber_width, METH_VARARGS, "\n"
		"Fl_Text_Display_linenumber_width(Fl_Text_Display self, int width)\n"
		"Fl_Text_Display_linenumber_width(Fl_Text_Display self) -> int\n"
		""},
	 { "Fl_Text_Display_linenumber_font", _wrap_Fl_Text_Display_linenumber_font, METH_VARARGS, "\n"
		"Fl_Text_Display_linenumber_font(Fl_Text_Display self, Fl_Font val)\n"
		"Fl_Text_Display_linenumber_font(Fl_Text_Display self) -> Fl_Font\n"
		""},
	 { "Fl_Text_Display_linenumber_size", _wrap_Fl_Text_Display_linenumber_size, METH_VARARGS, "\n"
		"Fl_Text_Display_linenumber_size(Fl_Text_Display self, Fl_Fontsize val)\n"
		"Fl_Text_Display_linenumber_size(Fl_Text_Display self) -> Fl_Fontsize\n"
		""},
	 { "Fl_Text_Display_linenumber_fgcolor", _wrap_Fl_Text_Display_linenumber_fgcolor, METH_VARARGS, "\n"
		"Fl_Text_Display_linenumber_fgcolor(Fl_Text_Display self, Fl_Color val)\n"
		"Fl_Text_Display_linenumber_fgcolor(Fl_Text_Display self) -> Fl_Color\n"
		""},
	 { "Fl_Text_Display_linenumber_bgcolor", _wrap_Fl_Text_Display_linenumber_bgcolor, METH_VARARGS, "\n"
		"Fl_Text_Display_linenumber_bgcolor(Fl_Text_Display self, Fl_Color val)\n"
		"Fl_Text_Display_linenumber_bgcolor(Fl_Text_Display self) -> Fl_Color\n"
		""},
	 { "Fl_Text_Display_linenumber_align", _wrap_Fl_Text_Display_linenumber_align, METH_VARARGS, "\n"
		"Fl_Text_Display_linenumber_align(Fl_Text_Display self, Fl_Align val)\n"
		"Fl_Text_Display_linenumber_align(Fl_Text_Display self) -> Fl_Align\n"
		""},
	 { "Fl_Text_Display_linenumber_format", _wrap_Fl_Text_Display_linenumber_format, METH_VARARGS, "\n"
		"Fl_Text_Display_linenumber_format(Fl_Text_Display self, char const * val)\n"
		"Fl_Text_Display_linenumber_format(Fl_Text_Display self) -> char const *\n"
		""},
	 { "Fl_Text_Display_draw", _wrap_Fl_Text_Display_draw, METH_O, "Fl_Text_Display_draw(Fl_Text_Display self)"},
	 { "Fl_Text_Display_get_absolute_top_line_number", _wrap_Fl_Text_Display_get_absolute_top_line_number, METH_O, "Fl_Text_Display_get_absolute_top_line_number(Fl_Text_Display self) -> int"},
	 { "Fl_Text_Display_scroll_row", _wrap_Fl_Text_Display_scroll_row, METH_O, "Fl_Text_Display_scroll_row(Fl_Text_Display self) -> int"},
	 { "Fl_Text_Display_scroll_col", _wrap_Fl_Text_Display_scroll_col, METH_O, "Fl_Text_Display_scroll_col(Fl_Text_Display self) -> int"},
	 { "Fl_Text_Display_init_type", _wrap_Fl_Text_Display_init_type, METH_VARARGS, "Fl_Text_Display_init_type(Fl_Text_Display self, char * Fl_Text_Display)"},
	 { "Fl_Text_Display_highlight_data", _wrap_Fl_Text_Display_highlight_data, METH_VARARGS, "Fl_Text_Display_highlight_data(Fl_Text_Display self, Fl_Text_Buffer styleBuffer, Fl_Text_Display::Style_Table_Entry const * styleTable, int nStyles, char unfinishedStyle, PyObject * func, PyObject * cbArg)"},
	 { "disown_Fl_Text_Display", _wrap_disown_Fl_Text_Display, METH_O, NULL},
	 { "Fl_Text_Display_swigregister", Fl_Text_Display_swigregister, METH_O, NULL},
	 { "Fl_Text_Display_swiginit", Fl_Text_Display_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Text_Editor", _wrap_new_Fl_Text_Editor, METH_VARARGS, "new_Fl_Text_Editor(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Text_Editor"},
	 { "delete_Fl_Text_Editor", _wrap_delete_Fl_Text_Editor, METH_O, "delete_Fl_Text_Editor(Fl_Text_Editor self)"},
	 { "Fl_Text_Editor_handle", _wrap_Fl_Text_Editor_handle, METH_VARARGS, "Fl_Text_Editor_handle(Fl_Text_Editor self, int e) -> int"},
	 { "Fl_Text_Editor_insert_mode", _wrap_Fl_Text_Editor_insert_mode, METH_VARARGS, "\n"
		"Fl_Text_Editor_insert_mode(Fl_Text_Editor self, int b)\n"
		"Fl_Text_Editor_insert_mode(Fl_Text_Editor self) -> int\n"
		""},
	 { "Fl_Text_Editor_tab_nav", _wrap_Fl_Text_Editor_tab_nav, METH_VARARGS, "\n"
		"Fl_Text_Editor_tab_nav(Fl_Text_Editor self, int val)\n"
		"Fl_Text_Editor_tab_nav(Fl_Text_Editor self) -> int\n"
		""},
	 { "Fl_Text_Editor_add_key_binding", _wrap_Fl_Text_Editor_add_key_binding, METH_VARARGS, "Fl_Text_Editor_add_key_binding(Fl_Text_Editor self, int key, int state, Fl_Text_Editor::Key_Func f)"},
	 { "Fl_Text_Editor_remove_key_binding", _wrap_Fl_Text_Editor_remove_key_binding, METH_VARARGS, "Fl_Text_Editor_remove_key_binding(Fl_Text_Editor self, int key, int state)"},
	 { "Fl_Text_Editor_remove_all_key_bindings", _wrap_Fl_Text_Editor_remove_all_key_bindings, METH_O, "Fl_Text_Editor_remove_all_key_bindings(Fl_Text_Editor self)"},
	 { "Fl_Text_Editor_bound_key_function", _wrap_Fl_Text_Editor_bound_key_function, METH_VARARGS, "\n"
		"Fl_Text_Editor_bound_key_function(Fl_Text_Editor self, int key, int state, Fl_Text_Editor::Key_Binding * list) -> Fl_Text_Editor::Key_Func\n"
		"Fl_Text_Editor_bound_key_function(Fl_Text_Editor self, int key, int state) -> Fl_Text_Editor::Key_Func\n"
		""},
	 { "Fl_Text_Editor_default_key_function", _wrap_Fl_Text_Editor_default_key_function, METH_VARARGS, "Fl_Text_Editor_default_key_function(Fl_Text_Editor self, Fl_Text_Editor::Key_Func f)"},
	 { "Fl_Text_Editor_kf_default", _wrap_Fl_Text_Editor_kf_default, METH_VARARGS, "Fl_Text_Editor_kf_default(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_ignore", _wrap_Fl_Text_Editor_kf_ignore, METH_VARARGS, "Fl_Text_Editor_kf_ignore(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_backspace", _wrap_Fl_Text_Editor_kf_backspace, METH_VARARGS, "Fl_Text_Editor_kf_backspace(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_enter", _wrap_Fl_Text_Editor_kf_enter, METH_VARARGS, "Fl_Text_Editor_kf_enter(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_move", _wrap_Fl_Text_Editor_kf_move, METH_VARARGS, "Fl_Text_Editor_kf_move(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_shift_move", _wrap_Fl_Text_Editor_kf_shift_move, METH_VARARGS, "Fl_Text_Editor_kf_shift_move(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_ctrl_move", _wrap_Fl_Text_Editor_kf_ctrl_move, METH_VARARGS, "Fl_Text_Editor_kf_ctrl_move(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_c_s_move", _wrap_Fl_Text_Editor_kf_c_s_move, METH_VARARGS, "Fl_Text_Editor_kf_c_s_move(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_meta_move", _wrap_Fl_Text_Editor_kf_meta_move, METH_VARARGS, "Fl_Text_Editor_kf_meta_move(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_m_s_move", _wrap_Fl_Text_Editor_kf_m_s_move, METH_VARARGS, "Fl_Text_Editor_kf_m_s_move(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_home", _wrap_Fl_Text_Editor_kf_home, METH_VARARGS, "Fl_Text_Editor_kf_home(int arg1, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_end", _wrap_Fl_Text_Editor_kf_end, METH_VARARGS, "Fl_Text_Editor_kf_end(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_left", _wrap_Fl_Text_Editor_kf_left, METH_VARARGS, "Fl_Text_Editor_kf_left(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_up", _wrap_Fl_Text_Editor_kf_up, METH_VARARGS, "Fl_Text_Editor_kf_up(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_right", _wrap_Fl_Text_Editor_kf_right, METH_VARARGS, "Fl_Text_Editor_kf_right(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_down", _wrap_Fl_Text_Editor_kf_down, METH_VARARGS, "Fl_Text_Editor_kf_down(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_page_up", _wrap_Fl_Text_Editor_kf_page_up, METH_VARARGS, "Fl_Text_Editor_kf_page_up(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_page_down", _wrap_Fl_Text_Editor_kf_page_down, METH_VARARGS, "Fl_Text_Editor_kf_page_down(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_insert", _wrap_Fl_Text_Editor_kf_insert, METH_VARARGS, "Fl_Text_Editor_kf_insert(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_delete", _wrap_Fl_Text_Editor_kf_delete, METH_VARARGS, "Fl_Text_Editor_kf_delete(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_copy", _wrap_Fl_Text_Editor_kf_copy, METH_VARARGS, "Fl_Text_Editor_kf_copy(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_cut", _wrap_Fl_Text_Editor_kf_cut, METH_VARARGS, "Fl_Text_Editor_kf_cut(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_paste", _wrap_Fl_Text_Editor_kf_paste, METH_VARARGS, "Fl_Text_Editor_kf_paste(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_select_all", _wrap_Fl_Text_Editor_kf_select_all, METH_VARARGS, "Fl_Text_Editor_kf_select_all(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_undo", _wrap_Fl_Text_Editor_kf_undo, METH_VARARGS, "Fl_Text_Editor_kf_undo(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_kf_redo", _wrap_Fl_Text_Editor_kf_redo, METH_VARARGS, "Fl_Text_Editor_kf_redo(int c, Fl_Text_Editor e) -> int"},
	 { "Fl_Text_Editor_init_type", _wrap_Fl_Text_Editor_init_type, METH_VARARGS, "Fl_Text_Editor_init_type(Fl_Text_Editor self, char * Fl_Text_Editor)"},
	 { "disown_Fl_Text_Editor", _wrap_disown_Fl_Text_Editor, METH_O, NULL},
	 { "Fl_Text_Editor_draw", _wrap_Fl_Text_Editor_draw, METH_O, "Fl_Text_Editor_draw(Fl_Text_Editor self)"},
	 { "Fl_Text_Editor_swigregister", Fl_Text_Editor_swigregister, METH_O, NULL},
	 { "Fl_Text_Editor_swiginit", Fl_Text_Editor_swiginit, METH_VARARGS, NULL},
	 { "Fl_Tile_handle", _wrap_Fl_Tile_handle, METH_VARARGS, "Fl_Tile_handle(Fl_Tile self, int event) -> int"},
	 { "new_Fl_Tile", _wrap_new_Fl_Tile, METH_VARARGS, "new_Fl_Tile(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Tile"},
	 { "delete_Fl_Tile", _wrap_delete_Fl_Tile, METH_O, "delete_Fl_Tile(Fl_Tile self)"},
	 { "Fl_Tile_resize", _wrap_Fl_Tile_resize, METH_VARARGS, "Fl_Tile_resize(Fl_Tile self, int X, int Y, int W, int H)"},
	 { "Fl_Tile_move_intersection", _wrap_Fl_Tile_move_intersection, METH_VARARGS, "Fl_Tile_move_intersection(Fl_Tile self, int oldx, int oldy, int newx, int newy)"},
	 { "Fl_Tile_drag_intersection", _wrap_Fl_Tile_drag_intersection, METH_VARARGS, "Fl_Tile_drag_intersection(Fl_Tile self, int oldx, int oldy, int newx, int newy)"},
	 { "Fl_Tile_size_range", _wrap_Fl_Tile_size_range, METH_VARARGS, "\n"
		"Fl_Tile_size_range(Fl_Tile self, int index, int minw, int minh, int maxw=2147483647, int maxh=2147483647)\n"
		"Fl_Tile_size_range(Fl_Tile self, Fl_Widget w, int minw, int minh, int maxw=2147483647, int maxh=2147483647)\n"
		""},
	 { "Fl_Tile_init_size_range", _wrap_Fl_Tile_init_size_range, METH_VARARGS, "Fl_Tile_init_size_range(Fl_Tile self, int default_min_w=-1, int default_min_h=-1)"},
	 { "Fl_Tile_init_type", _wrap_Fl_Tile_init_type, METH_VARARGS, "Fl_Tile_init_type(Fl_Tile self, char * Fl_Tile)"},
	 { "disown_Fl_Tile", _wrap_disown_Fl_Tile, METH_O, NULL},
	 { "Fl_Tile_draw", _wrap_Fl_Tile_draw, METH_O, "Fl_Tile_draw(Fl_Tile self)"},
	 { "Fl_Tile_swigregister", Fl_Tile_swigregister, METH_O, NULL},
	 { "Fl_Tile_swiginit", Fl_Tile_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Tiled_Image", _wrap_new_Fl_Tiled_Image, METH_VARARGS, "new_Fl_Tiled_Image(PyObject * _self, Fl_Image i, int W=0, int H=0) -> Fl_Tiled_Image"},
	 { "delete_Fl_Tiled_Image", _wrap_delete_Fl_Tiled_Image, METH_O, "delete_Fl_Tiled_Image(Fl_Tiled_Image self)"},
	 { "Fl_Tiled_Image_copy", _wrap_Fl_Tiled_Image_copy, METH_VARARGS, "\n"
		"Fl_Tiled_Image_copy(Fl_Tiled_Image self, int W, int H) -> Fl_Image\n"
		"Fl_Tiled_Image_copy(Fl_Tiled_Image self) -> Fl_Image\n"
		""},
	 { "Fl_Tiled_Image_color_average", _wrap_Fl_Tiled_Image_color_average, METH_VARARGS, "Fl_Tiled_Image_color_average(Fl_Tiled_Image self, Fl_Color c, float i)"},
	 { "Fl_Tiled_Image_desaturate", _wrap_Fl_Tiled_Image_desaturate, METH_O, "Fl_Tiled_Image_desaturate(Fl_Tiled_Image self)"},
	 { "Fl_Tiled_Image_draw", _wrap_Fl_Tiled_Image_draw, METH_VARARGS, "\n"
		"Fl_Tiled_Image_draw(Fl_Tiled_Image self, int X, int Y, int W, int H, int cx=0, int cy=0)\n"
		"Fl_Tiled_Image_draw(Fl_Tiled_Image self, int X, int Y)\n"
		""},
	 { "Fl_Tiled_Image_image", _wrap_Fl_Tiled_Image_image, METH_O, "Fl_Tiled_Image_image(Fl_Tiled_Image self) -> Fl_Image"},
	 { "disown_Fl_Tiled_Image", _wrap_disown_Fl_Tiled_Image, METH_O, NULL},
	 { "Fl_Tiled_Image_swigregister", Fl_Tiled_Image_swigregister, METH_O, NULL},
	 { "Fl_Tiled_Image_swiginit", Fl_Tiled_Image_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Toggle_Button", _wrap_new_Fl_Toggle_Button, METH_VARARGS, "new_Fl_Toggle_Button(PyObject * _self, int X, int Y, int W, int H, char const * l=None) -> Fl_Toggle_Button"},
	 { "Fl_Toggle_Button_init_type", _wrap_Fl_Toggle_Button_init_type, METH_VARARGS, "Fl_Toggle_Button_init_type(Fl_Toggle_Button self, char * Fl_Toggle_Button)"},
	 { "delete_Fl_Toggle_Button", _wrap_delete_Fl_Toggle_Button, METH_O, "delete_Fl_Toggle_Button(Fl_Toggle_Button self)"},
	 { "disown_Fl_Toggle_Button", _wrap_disown_Fl_Toggle_Button, METH_O, NULL},
	 { "Fl_Toggle_Button_draw", _wrap_Fl_Toggle_Button_draw, METH_O, "Fl_Toggle_Button_draw(Fl_Toggle_Button self)"},
	 { "Fl_Toggle_Button_swigregister", Fl_Toggle_Button_swigregister, METH_O, NULL},
	 { "Fl_Toggle_Button_swiginit", Fl_Toggle_Button_swiginit, METH_VARARGS, NULL},
	 { "Fl_Tooltip_delay", _wrap_Fl_Tooltip_delay, METH_VARARGS, "\n"
		"Fl_Tooltip_delay() -> float\n"
		"Fl_Tooltip_delay(float f)\n"
		""},
	 { "Fl_Tooltip_hidedelay", _wrap_Fl_Tooltip_hidedelay, METH_VARARGS, "\n"
		"Fl_Tooltip_hidedelay() -> float\n"
		"Fl_Tooltip_hidedelay(float f)\n"
		""},
	 { "Fl_Tooltip_hoverdelay", _wrap_Fl_Tooltip_hoverdelay, METH_VARARGS, "\n"
		"Fl_Tooltip_hoverdelay() -> float\n"
		"Fl_Tooltip_hoverdelay(float f)\n"
		""},
	 { "Fl_Tooltip_enabled", _wrap_Fl_Tooltip_enabled, METH_NOARGS, "Fl_Tooltip_enabled() -> int"},
	 { "Fl_Tooltip_enable", _wrap_Fl_Tooltip_enable, METH_VARARGS, "Fl_Tooltip_enable(int b=1)"},
	 { "Fl_Tooltip_disable", _wrap_Fl_Tooltip_disable, METH_NOARGS, "Fl_Tooltip_disable()"},
	 { "Fl_Tooltip_enter_area", _wrap_Fl_Tooltip_enter_area, METH_VARARGS, "Fl_Tooltip_enter_area(Fl_Widget w, int X, int Y, int W, int H, char const * tip)"},
	 { "Fl_Tooltip_current", _wrap_Fl_Tooltip_current, METH_VARARGS, "\n"
		"Fl_Tooltip_current() -> Fl_Widget\n"
		"Fl_Tooltip_current(Fl_Widget arg1)\n"
		""},
	 { "Fl_Tooltip_font", _wrap_Fl_Tooltip_font, METH_VARARGS, "\n"
		"Fl_Tooltip_font() -> Fl_Font\n"
		"Fl_Tooltip_font(Fl_Font i)\n"
		""},
	 { "Fl_Tooltip_size", _wrap_Fl_Tooltip_size, METH_VARARGS, "\n"
		"Fl_Tooltip_size() -> Fl_Fontsize\n"
		"Fl_Tooltip_size(Fl_Fontsize s)\n"
		""},
	 { "Fl_Tooltip_color", _wrap_Fl_Tooltip_color, METH_VARARGS, "\n"
		"Fl_Tooltip_color() -> Fl_Color\n"
		"Fl_Tooltip_color(Fl_Color c)\n"
		""},
	 { "Fl_Tooltip_textcolor", _wrap_Fl_Tooltip_textcolor, METH_VARARGS, "\n"
		"Fl_Tooltip_textcolor() -> Fl_Color\n"
		"Fl_Tooltip_textcolor(Fl_Color c)\n"
		""},
	 { "Fl_Tooltip_margin_width", _wrap_Fl_Tooltip_margin_width, METH_VARARGS, "\n"
		"Fl_Tooltip_margin_width() -> int\n"
		"Fl_Tooltip_margin_width(int v)\n"
		""},
	 { "Fl_Tooltip_margin_height", _wrap_Fl_Tooltip_margin_height, METH_VARARGS, "\n"
		"Fl_Tooltip_margin_height() -> int\n"
		"Fl_Tooltip_margin_height(int v)\n"
		""},
	 { "Fl_Tooltip_wrap_width", _wrap_Fl_Tooltip_wrap_width, METH_VARARGS, "\n"
		"Fl_Tooltip_wrap_width() -> int\n"
		"Fl_Tooltip_wrap_width(int v)\n"
		""},
	 { "Fl_Tooltip_current_window", _wrap_Fl_Tooltip_current_window, METH_NOARGS, "Fl_Tooltip_current_window() -> Fl_Window"},
	 { "Fl_Tooltip_override_text", _wrap_Fl_Tooltip_override_text, METH_O, "Fl_Tooltip_override_text(char const * new_text) -> int"},
	 { "new_Fl_Tooltip", _wrap_new_Fl_Tooltip, METH_NOARGS, "new_Fl_Tooltip() -> Fl_Tooltip"},
	 { "delete_Fl_Tooltip", _wrap_delete_Fl_Tooltip, METH_O, "delete_Fl_Tooltip(Fl_Tooltip self)"},
	 { "Fl_Tooltip_swigregister", Fl_Tooltip_swigregister, METH_O, NULL},
	 { "Fl_Tooltip_swiginit", Fl_Tooltip_swiginit, METH_VARARGS, NULL},
	 { "Fl_Value_Output_draw", _wrap_Fl_Value_Output_draw, METH_O, "Fl_Value_Output_draw(Fl_Value_Output self)"},
	 { "Fl_Value_Output_handle", _wrap_Fl_Value_Output_handle, METH_VARARGS, "Fl_Value_Output_handle(Fl_Value_Output self, int arg0) -> int"},
	 { "new_Fl_Value_Output", _wrap_new_Fl_Value_Output, METH_VARARGS, "new_Fl_Value_Output(PyObject * _self, int x, int y, int w, int h, char const * l=None) -> Fl_Value_Output"},
	 { "Fl_Value_Output_soft", _wrap_Fl_Value_Output_soft, METH_VARARGS, "\n"
		"Fl_Value_Output_soft(Fl_Value_Output self, uchar s)\n"
		"Fl_Value_Output_soft(Fl_Value_Output self) -> uchar\n"
		""},
	 { "Fl_Value_Output_textfont", _wrap_Fl_Value_Output_textfont, METH_VARARGS, "\n"
		"Fl_Value_Output_textfont(Fl_Value_Output self) -> Fl_Font\n"
		"Fl_Value_Output_textfont(Fl_Value_Output self, Fl_Font s)\n"
		""},
	 { "Fl_Value_Output_textsize", _wrap_Fl_Value_Output_textsize, METH_VARARGS, "\n"
		"Fl_Value_Output_textsize(Fl_Value_Output self) -> Fl_Fontsize\n"
		"Fl_Value_Output_textsize(Fl_Value_Output self, Fl_Fontsize s)\n"
		""},
	 { "Fl_Value_Output_textcolor", _wrap_Fl_Value_Output_textcolor, METH_VARARGS, "\n"
		"Fl_Value_Output_textcolor(Fl_Value_Output self) -> Fl_Color\n"
		"Fl_Value_Output_textcolor(Fl_Value_Output self, Fl_Color s)\n"
		""},
	 { "Fl_Value_Output_init_type", _wrap_Fl_Value_Output_init_type, METH_VARARGS, "Fl_Value_Output_init_type(Fl_Value_Output self, char * Fl_Value_Output)"},
	 { "delete_Fl_Value_Output", _wrap_delete_Fl_Value_Output, METH_O, "delete_Fl_Value_Output(Fl_Value_Output self)"},
	 { "disown_Fl_Value_Output", _wrap_disown_Fl_Value_Output, METH_O, NULL},
	 { "Fl_Value_Output_swigregister", Fl_Value_Output_swigregister, METH_O, NULL},
	 { "Fl_Value_Output_swiginit", Fl_Value_Output_swiginit, METH_VARARGS, NULL},
	 { "Fl_Wizard_draw", _wrap_Fl_Wizard_draw, METH_O, "Fl_Wizard_draw(Fl_Wizard self)"},
	 { "new_Fl_Wizard", _wrap_new_Fl_Wizard, METH_VARARGS, "new_Fl_Wizard(PyObject * _self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Wizard"},
	 { "Fl_Wizard_next", _wrap_Fl_Wizard_next, METH_O, "Fl_Wizard_next(Fl_Wizard self)"},
	 { "Fl_Wizard_prev", _wrap_Fl_Wizard_prev, METH_O, "Fl_Wizard_prev(Fl_Wizard self)"},
	 { "Fl_Wizard_value", _wrap_Fl_Wizard_value, METH_VARARGS, "\n"
		"Fl_Wizard_value(Fl_Wizard self) -> Fl_Widget\n"
		"Fl_Wizard_value(Fl_Wizard self, Fl_Widget arg2)\n"
		""},
	 { "Fl_Wizard_init_type", _wrap_Fl_Wizard_init_type, METH_VARARGS, "Fl_Wizard_init_type(Fl_Wizard self, char * Fl_Wizard)"},
	 { "delete_Fl_Wizard", _wrap_delete_Fl_Wizard, METH_O, "delete_Fl_Wizard(Fl_Wizard self)"},
	 { "disown_Fl_Wizard", _wrap_disown_Fl_Wizard, METH_O, NULL},
	 { "Fl_Wizard_swigregister", Fl_Wizard_swigregister, METH_O, NULL},
	 { "Fl_Wizard_swiginit", Fl_Wizard_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_XBM_Image", _wrap_new_Fl_XBM_Image, METH_VARARGS, "new_Fl_XBM_Image(PyObject * _self, char const * filename) -> Fl_XBM_Image"},
	 { "delete_Fl_XBM_Image", _wrap_delete_Fl_XBM_Image, METH_O, "delete_Fl_XBM_Image(Fl_XBM_Image self)"},
	 { "disown_Fl_XBM_Image", _wrap_disown_Fl_XBM_Image, METH_O, NULL},
	 { "Fl_XBM_Image_swigregister", Fl_XBM_Image_swigregister, METH_O, NULL},
	 { "Fl_XBM_Image_swiginit", Fl_XBM_Image_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_XPM_Image", _wrap_new_Fl_XPM_Image, METH_VARARGS, "new_Fl_XPM_Image(PyObject * _self, char const * filename) -> Fl_XPM_Image"},
	 { "delete_Fl_XPM_Image", _wrap_delete_Fl_XPM_Image, METH_O, "delete_Fl_XPM_Image(Fl_XPM_Image self)"},
	 { "disown_Fl_XPM_Image", _wrap_disown_Fl_XPM_Image, METH_O, NULL},
	 { "Fl_XPM_Image_swigregister", Fl_XPM_Image_swigregister, METH_O, NULL},
	 { "Fl_XPM_Image_swiginit", Fl_XPM_Image_swiginit, METH_VARARGS, NULL},
	 { "Fl_X_flx", _wrap_Fl_X_flx, METH_O, "Fl_X_flx(Fl_Window w) -> Fl_X"},
	 { "new_Fl_X", _wrap_new_Fl_X, METH_NOARGS, "new_Fl_X() -> Fl_X"},
	 { "delete_Fl_X", _wrap_delete_Fl_X, METH_O, "delete_Fl_X(Fl_X self)"},
	 { "Fl_X_swigregister", Fl_X_swigregister, METH_O, NULL},
	 { "Fl_X_swiginit", Fl_X_swiginit, METH_VARARGS, NULL},
	 { "fl_xid", _wrap_fl_xid, METH_O, "fl_xid(Fl_Window w) -> Window"},
	 { "fl_find", _wrap_fl_find, METH_O, "fl_find(Window xid) -> Fl_Window"},
	 { "fl_open_display", _wrap_fl_open_display, METH_NOARGS, "fl_open_display()"},
	 { "fl_close_display", _wrap_fl_close_display, METH_NOARGS, "fl_close_display()"},
	 { "fl_parse_color", _wrap_fl_parse_color, METH_VARARGS, "fl_parse_color(char const * p, uchar & r, uchar & g, uchar & b) -> int"},
	 { "fl_open_callback", _wrap_fl_open_callback, METH_O, "fl_open_callback(void (*)(char const *) arg1)"},
	 { "new_Fl_Tree_Prefs", _wrap_new_Fl_Tree_Prefs, METH_NOARGS, "new_Fl_Tree_Prefs() -> Fl_Tree_Prefs"},
	 { "delete_Fl_Tree_Prefs", _wrap_delete_Fl_Tree_Prefs, METH_O, "delete_Fl_Tree_Prefs(Fl_Tree_Prefs self)"},
	 { "Fl_Tree_Prefs_item_labelfont", _wrap_Fl_Tree_Prefs_item_labelfont, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_item_labelfont(Fl_Tree_Prefs self) -> Fl_Font\n"
		"Fl_Tree_Prefs_item_labelfont(Fl_Tree_Prefs self, Fl_Font val)\n"
		""},
	 { "Fl_Tree_Prefs_item_labelsize", _wrap_Fl_Tree_Prefs_item_labelsize, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_item_labelsize(Fl_Tree_Prefs self) -> Fl_Fontsize\n"
		"Fl_Tree_Prefs_item_labelsize(Fl_Tree_Prefs self, Fl_Fontsize val)\n"
		""},
	 { "Fl_Tree_Prefs_item_labelfgcolor", _wrap_Fl_Tree_Prefs_item_labelfgcolor, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_item_labelfgcolor(Fl_Tree_Prefs self) -> Fl_Color\n"
		"Fl_Tree_Prefs_item_labelfgcolor(Fl_Tree_Prefs self, Fl_Color val)\n"
		""},
	 { "Fl_Tree_Prefs_item_labelbgcolor", _wrap_Fl_Tree_Prefs_item_labelbgcolor, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_item_labelbgcolor(Fl_Tree_Prefs self) -> Fl_Color\n"
		"Fl_Tree_Prefs_item_labelbgcolor(Fl_Tree_Prefs self, Fl_Color val)\n"
		""},
	 { "Fl_Tree_Prefs_labelfont", _wrap_Fl_Tree_Prefs_labelfont, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_labelfont(Fl_Tree_Prefs self) -> Fl_Font\n"
		"Fl_Tree_Prefs_labelfont(Fl_Tree_Prefs self, Fl_Font val)\n"
		""},
	 { "Fl_Tree_Prefs_labelsize", _wrap_Fl_Tree_Prefs_labelsize, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_labelsize(Fl_Tree_Prefs self) -> Fl_Fontsize\n"
		"Fl_Tree_Prefs_labelsize(Fl_Tree_Prefs self, Fl_Fontsize val)\n"
		""},
	 { "Fl_Tree_Prefs_labelfgcolor", _wrap_Fl_Tree_Prefs_labelfgcolor, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_labelfgcolor(Fl_Tree_Prefs self) -> Fl_Color\n"
		"Fl_Tree_Prefs_labelfgcolor(Fl_Tree_Prefs self, Fl_Color val)\n"
		""},
	 { "Fl_Tree_Prefs_labelbgcolor", _wrap_Fl_Tree_Prefs_labelbgcolor, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_labelbgcolor(Fl_Tree_Prefs self) -> Fl_Color\n"
		"Fl_Tree_Prefs_labelbgcolor(Fl_Tree_Prefs self, Fl_Color val)\n"
		""},
	 { "Fl_Tree_Prefs_marginleft", _wrap_Fl_Tree_Prefs_marginleft, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_marginleft(Fl_Tree_Prefs self) -> int\n"
		"Fl_Tree_Prefs_marginleft(Fl_Tree_Prefs self, int val)\n"
		""},
	 { "Fl_Tree_Prefs_margintop", _wrap_Fl_Tree_Prefs_margintop, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_margintop(Fl_Tree_Prefs self) -> int\n"
		"Fl_Tree_Prefs_margintop(Fl_Tree_Prefs self, int val)\n"
		""},
	 { "Fl_Tree_Prefs_marginbottom", _wrap_Fl_Tree_Prefs_marginbottom, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_marginbottom(Fl_Tree_Prefs self) -> int\n"
		"Fl_Tree_Prefs_marginbottom(Fl_Tree_Prefs self, int val)\n"
		""},
	 { "Fl_Tree_Prefs_openchild_marginbottom", _wrap_Fl_Tree_Prefs_openchild_marginbottom, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_openchild_marginbottom(Fl_Tree_Prefs self) -> int\n"
		"Fl_Tree_Prefs_openchild_marginbottom(Fl_Tree_Prefs self, int val)\n"
		""},
	 { "Fl_Tree_Prefs_usericonmarginleft", _wrap_Fl_Tree_Prefs_usericonmarginleft, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_usericonmarginleft(Fl_Tree_Prefs self) -> int\n"
		"Fl_Tree_Prefs_usericonmarginleft(Fl_Tree_Prefs self, int val)\n"
		""},
	 { "Fl_Tree_Prefs_labelmarginleft", _wrap_Fl_Tree_Prefs_labelmarginleft, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_labelmarginleft(Fl_Tree_Prefs self) -> int\n"
		"Fl_Tree_Prefs_labelmarginleft(Fl_Tree_Prefs self, int val)\n"
		""},
	 { "Fl_Tree_Prefs_widgetmarginleft", _wrap_Fl_Tree_Prefs_widgetmarginleft, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_widgetmarginleft(Fl_Tree_Prefs self) -> int\n"
		"Fl_Tree_Prefs_widgetmarginleft(Fl_Tree_Prefs self, int val)\n"
		""},
	 { "Fl_Tree_Prefs_linespacing", _wrap_Fl_Tree_Prefs_linespacing, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_linespacing(Fl_Tree_Prefs self) -> int\n"
		"Fl_Tree_Prefs_linespacing(Fl_Tree_Prefs self, int val)\n"
		""},
	 { "Fl_Tree_Prefs_connectorcolor", _wrap_Fl_Tree_Prefs_connectorcolor, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_connectorcolor(Fl_Tree_Prefs self) -> Fl_Color\n"
		"Fl_Tree_Prefs_connectorcolor(Fl_Tree_Prefs self, Fl_Color val)\n"
		""},
	 { "Fl_Tree_Prefs_connectorstyle", _wrap_Fl_Tree_Prefs_connectorstyle, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_connectorstyle(Fl_Tree_Prefs self) -> Fl_Tree_Connector\n"
		"Fl_Tree_Prefs_connectorstyle(Fl_Tree_Prefs self, Fl_Tree_Connector val)\n"
		"Fl_Tree_Prefs_connectorstyle(Fl_Tree_Prefs self, int val)\n"
		""},
	 { "Fl_Tree_Prefs_connectorwidth", _wrap_Fl_Tree_Prefs_connectorwidth, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_connectorwidth(Fl_Tree_Prefs self) -> int\n"
		"Fl_Tree_Prefs_connectorwidth(Fl_Tree_Prefs self, int val)\n"
		""},
	 { "Fl_Tree_Prefs_openicon_w", _wrap_Fl_Tree_Prefs_openicon_w, METH_O, "Fl_Tree_Prefs_openicon_w(Fl_Tree_Prefs self) -> int"},
	 { "Fl_Tree_Prefs_openicon_h", _wrap_Fl_Tree_Prefs_openicon_h, METH_O, "Fl_Tree_Prefs_openicon_h(Fl_Tree_Prefs self) -> int"},
	 { "Fl_Tree_Prefs_openicon", _wrap_Fl_Tree_Prefs_openicon, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_openicon(Fl_Tree_Prefs self) -> Fl_Image\n"
		"Fl_Tree_Prefs_openicon(Fl_Tree_Prefs self, Fl_Image val)\n"
		""},
	 { "Fl_Tree_Prefs_closeicon_w", _wrap_Fl_Tree_Prefs_closeicon_w, METH_O, "Fl_Tree_Prefs_closeicon_w(Fl_Tree_Prefs self) -> int"},
	 { "Fl_Tree_Prefs_closeicon_h", _wrap_Fl_Tree_Prefs_closeicon_h, METH_O, "Fl_Tree_Prefs_closeicon_h(Fl_Tree_Prefs self) -> int"},
	 { "Fl_Tree_Prefs_closeicon", _wrap_Fl_Tree_Prefs_closeicon, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_closeicon(Fl_Tree_Prefs self) -> Fl_Image\n"
		"Fl_Tree_Prefs_closeicon(Fl_Tree_Prefs self, Fl_Image val)\n"
		""},
	 { "Fl_Tree_Prefs_usericon", _wrap_Fl_Tree_Prefs_usericon, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_usericon(Fl_Tree_Prefs self) -> Fl_Image\n"
		"Fl_Tree_Prefs_usericon(Fl_Tree_Prefs self, Fl_Image val)\n"
		""},
	 { "Fl_Tree_Prefs_opendeicon", _wrap_Fl_Tree_Prefs_opendeicon, METH_O, "Fl_Tree_Prefs_opendeicon(Fl_Tree_Prefs self) -> Fl_Image"},
	 { "Fl_Tree_Prefs_closedeicon", _wrap_Fl_Tree_Prefs_closedeicon, METH_O, "Fl_Tree_Prefs_closedeicon(Fl_Tree_Prefs self) -> Fl_Image"},
	 { "Fl_Tree_Prefs_userdeicon", _wrap_Fl_Tree_Prefs_userdeicon, METH_O, "Fl_Tree_Prefs_userdeicon(Fl_Tree_Prefs self) -> Fl_Image"},
	 { "Fl_Tree_Prefs_showcollapse", _wrap_Fl_Tree_Prefs_showcollapse, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_showcollapse(Fl_Tree_Prefs self) -> char\n"
		"Fl_Tree_Prefs_showcollapse(Fl_Tree_Prefs self, int val)\n"
		""},
	 { "Fl_Tree_Prefs_sortorder", _wrap_Fl_Tree_Prefs_sortorder, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_sortorder(Fl_Tree_Prefs self) -> Fl_Tree_Sort\n"
		"Fl_Tree_Prefs_sortorder(Fl_Tree_Prefs self, Fl_Tree_Sort val)\n"
		""},
	 { "Fl_Tree_Prefs_selectbox", _wrap_Fl_Tree_Prefs_selectbox, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_selectbox(Fl_Tree_Prefs self) -> Fl_Boxtype\n"
		"Fl_Tree_Prefs_selectbox(Fl_Tree_Prefs self, Fl_Boxtype val)\n"
		""},
	 { "Fl_Tree_Prefs_showroot", _wrap_Fl_Tree_Prefs_showroot, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_showroot(Fl_Tree_Prefs self) -> int\n"
		"Fl_Tree_Prefs_showroot(Fl_Tree_Prefs self, int val)\n"
		""},
	 { "Fl_Tree_Prefs_selectmode", _wrap_Fl_Tree_Prefs_selectmode, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_selectmode(Fl_Tree_Prefs self) -> Fl_Tree_Select\n"
		"Fl_Tree_Prefs_selectmode(Fl_Tree_Prefs self, Fl_Tree_Select val)\n"
		""},
	 { "Fl_Tree_Prefs_item_reselect_mode", _wrap_Fl_Tree_Prefs_item_reselect_mode, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_item_reselect_mode(Fl_Tree_Prefs self) -> Fl_Tree_Item_Reselect_Mode\n"
		"Fl_Tree_Prefs_item_reselect_mode(Fl_Tree_Prefs self, Fl_Tree_Item_Reselect_Mode mode)\n"
		""},
	 { "Fl_Tree_Prefs_item_draw_mode", _wrap_Fl_Tree_Prefs_item_draw_mode, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_item_draw_mode(Fl_Tree_Prefs self) -> Fl_Tree_Item_Draw_Mode\n"
		"Fl_Tree_Prefs_item_draw_mode(Fl_Tree_Prefs self, Fl_Tree_Item_Draw_Mode val)\n"
		""},
	 { "Fl_Tree_Prefs_item_draw_callback", _wrap_Fl_Tree_Prefs_item_draw_callback, METH_VARARGS, "\n"
		"Fl_Tree_Prefs_item_draw_callback(Fl_Tree_Prefs self, Fl_Tree_Item_Draw_Callback * cb, void * data=None)\n"
		"Fl_Tree_Prefs_item_draw_callback(Fl_Tree_Prefs self) -> Fl_Tree_Item_Draw_Callback *\n"
		""},
	 { "Fl_Tree_Prefs_item_draw_user_data", _wrap_Fl_Tree_Prefs_item_draw_user_data, METH_O, "Fl_Tree_Prefs_item_draw_user_data(Fl_Tree_Prefs self) -> void *"},
	 { "Fl_Tree_Prefs_do_item_draw_callback", _wrap_Fl_Tree_Prefs_do_item_draw_callback, METH_VARARGS, "Fl_Tree_Prefs_do_item_draw_callback(Fl_Tree_Prefs self, Fl_Tree_Item o)"},
	 { "Fl_Tree_Prefs_swigregister", Fl_Tree_Prefs_swigregister, METH_O, NULL},
	 { "Fl_Tree_Prefs_swiginit", Fl_Tree_Prefs_swiginit, METH_VARARGS, NULL},
	 { "delete_Fl_Tree_Item_Array", _wrap_delete_Fl_Tree_Item_Array, METH_O, "delete_Fl_Tree_Item_Array(Fl_Tree_Item_Array self)"},
	 { "new_Fl_Tree_Item_Array", _wrap_new_Fl_Tree_Item_Array, METH_VARARGS, "\n"
		"Fl_Tree_Item_Array(int new_chunksize=10)\n"
		"new_Fl_Tree_Item_Array(Fl_Tree_Item_Array o) -> Fl_Tree_Item_Array\n"
		""},
	 { "Fl_Tree_Item_Array_total", _wrap_Fl_Tree_Item_Array_total, METH_O, "Fl_Tree_Item_Array_total(Fl_Tree_Item_Array self) -> int"},
	 { "Fl_Tree_Item_Array_swap", _wrap_Fl_Tree_Item_Array_swap, METH_VARARGS, "Fl_Tree_Item_Array_swap(Fl_Tree_Item_Array self, int ax, int bx)"},
	 { "Fl_Tree_Item_Array_move", _wrap_Fl_Tree_Item_Array_move, METH_VARARGS, "Fl_Tree_Item_Array_move(Fl_Tree_Item_Array self, int to, int _from) -> int"},
	 { "Fl_Tree_Item_Array_deparent", _wrap_Fl_Tree_Item_Array_deparent, METH_VARARGS, "Fl_Tree_Item_Array_deparent(Fl_Tree_Item_Array self, int pos) -> int"},
	 { "Fl_Tree_Item_Array_reparent", _wrap_Fl_Tree_Item_Array_reparent, METH_VARARGS, "Fl_Tree_Item_Array_reparent(Fl_Tree_Item_Array self, Fl_Tree_Item item, Fl_Tree_Item newparent, int pos) -> int"},
	 { "Fl_Tree_Item_Array_clear", _wrap_Fl_Tree_Item_Array_clear, METH_O, "Fl_Tree_Item_Array_clear(Fl_Tree_Item_Array self)"},
	 { "Fl_Tree_Item_Array_add", _wrap_Fl_Tree_Item_Array_add, METH_VARARGS, "Fl_Tree_Item_Array_add(Fl_Tree_Item_Array self, Fl_Tree_Item val)"},
	 { "Fl_Tree_Item_Array_insert", _wrap_Fl_Tree_Item_Array_insert, METH_VARARGS, "Fl_Tree_Item_Array_insert(Fl_Tree_Item_Array self, int pos, Fl_Tree_Item new_item)"},
	 { "Fl_Tree_Item_Array_replace", _wrap_Fl_Tree_Item_Array_replace, METH_VARARGS, "Fl_Tree_Item_Array_replace(Fl_Tree_Item_Array self, int pos, Fl_Tree_Item new_item)"},
	 { "Fl_Tree_Item_Array_remove", _wrap_Fl_Tree_Item_Array_remove, METH_VARARGS, "\n"
		"Fl_Tree_Item_Array_remove(Fl_Tree_Item_Array self, int index)\n"
		"Fl_Tree_Item_Array_remove(Fl_Tree_Item_Array self, Fl_Tree_Item item) -> int\n"
		""},
	 { "Fl_Tree_Item_Array_manage_item_destroy", _wrap_Fl_Tree_Item_Array_manage_item_destroy, METH_VARARGS, "\n"
		"Fl_Tree_Item_Array_manage_item_destroy(Fl_Tree_Item_Array self, int val)\n"
		"Fl_Tree_Item_Array_manage_item_destroy(Fl_Tree_Item_Array self) -> int\n"
		""},
	 { "Fl_Tree_Item_Array_swigregister", Fl_Tree_Item_Array_swigregister, METH_O, NULL},
	 { "Fl_Tree_Item_Array_swiginit", Fl_Tree_Item_Array_swiginit, METH_VARARGS, NULL},
	 { "Fl_Tree_Item_draw_vertical_connector", _wrap_Fl_Tree_Item_draw_vertical_connector, METH_VARARGS, "Fl_Tree_Item_draw_vertical_connector(Fl_Tree_Item self, int x, int y1, int y2, Fl_Tree_Prefs prefs)"},
	 { "Fl_Tree_Item_draw_horizontal_connector", _wrap_Fl_Tree_Item_draw_horizontal_connector, METH_VARARGS, "Fl_Tree_Item_draw_horizontal_connector(Fl_Tree_Item self, int x1, int x2, int y, Fl_Tree_Prefs prefs)"},
	 { "delete_Fl_Tree_Item", _wrap_delete_Fl_Tree_Item, METH_O, "delete_Fl_Tree_Item(Fl_Tree_Item self)"},
	 { "new_Fl_Tree_Item", _wrap_new_Fl_Tree_Item, METH_VARARGS, "\n"
		"Fl_Tree_Item(Fl_Tree_Prefs prefs)\n"
		"Fl_Tree_Item(Fl_Tree tree)\n"
		"new_Fl_Tree_Item(PyObject * _self, Fl_Tree_Item o) -> Fl_Tree_Item\n"
		""},
	 { "Fl_Tree_Item_x", _wrap_Fl_Tree_Item_x, METH_O, "Fl_Tree_Item_x(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_y", _wrap_Fl_Tree_Item_y, METH_O, "Fl_Tree_Item_y(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_w", _wrap_Fl_Tree_Item_w, METH_O, "Fl_Tree_Item_w(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_h", _wrap_Fl_Tree_Item_h, METH_O, "Fl_Tree_Item_h(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_label_x", _wrap_Fl_Tree_Item_label_x, METH_O, "Fl_Tree_Item_label_x(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_label_y", _wrap_Fl_Tree_Item_label_y, METH_O, "Fl_Tree_Item_label_y(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_label_w", _wrap_Fl_Tree_Item_label_w, METH_O, "Fl_Tree_Item_label_w(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_label_h", _wrap_Fl_Tree_Item_label_h, METH_O, "Fl_Tree_Item_label_h(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_draw_item_content", _wrap_Fl_Tree_Item_draw_item_content, METH_VARARGS, "Fl_Tree_Item_draw_item_content(Fl_Tree_Item self, int render) -> int"},
	 { "Fl_Tree_Item_draw", _wrap_Fl_Tree_Item_draw, METH_VARARGS, "Fl_Tree_Item_draw(Fl_Tree_Item self, int X, int & Y, int W, Fl_Tree_Item itemfocus, int lastchild=1, int render=1)"},
	 { "Fl_Tree_Item_show_self", _wrap_Fl_Tree_Item_show_self, METH_VARARGS, "Fl_Tree_Item_show_self(Fl_Tree_Item self, char const * indent=\"\")"},
	 { "Fl_Tree_Item_label", _wrap_Fl_Tree_Item_label, METH_VARARGS, "\n"
		"Fl_Tree_Item_label(Fl_Tree_Item self, char const * val)\n"
		"Fl_Tree_Item_label(Fl_Tree_Item self) -> char const *\n"
		""},
	 { "Fl_Tree_Item_labelfont", _wrap_Fl_Tree_Item_labelfont, METH_VARARGS, "\n"
		"Fl_Tree_Item_labelfont(Fl_Tree_Item self, Fl_Font val)\n"
		"Fl_Tree_Item_labelfont(Fl_Tree_Item self) -> Fl_Font\n"
		""},
	 { "Fl_Tree_Item_labelsize", _wrap_Fl_Tree_Item_labelsize, METH_VARARGS, "\n"
		"Fl_Tree_Item_labelsize(Fl_Tree_Item self, Fl_Fontsize val)\n"
		"Fl_Tree_Item_labelsize(Fl_Tree_Item self) -> Fl_Fontsize\n"
		""},
	 { "Fl_Tree_Item_labelfgcolor", _wrap_Fl_Tree_Item_labelfgcolor, METH_VARARGS, "\n"
		"Fl_Tree_Item_labelfgcolor(Fl_Tree_Item self, Fl_Color val)\n"
		"Fl_Tree_Item_labelfgcolor(Fl_Tree_Item self) -> Fl_Color\n"
		""},
	 { "Fl_Tree_Item_labelcolor", _wrap_Fl_Tree_Item_labelcolor, METH_VARARGS, "\n"
		"Fl_Tree_Item_labelcolor(Fl_Tree_Item self, Fl_Color val)\n"
		"Fl_Tree_Item_labelcolor(Fl_Tree_Item self) -> Fl_Color\n"
		""},
	 { "Fl_Tree_Item_labelbgcolor", _wrap_Fl_Tree_Item_labelbgcolor, METH_VARARGS, "\n"
		"Fl_Tree_Item_labelbgcolor(Fl_Tree_Item self, Fl_Color val)\n"
		"Fl_Tree_Item_labelbgcolor(Fl_Tree_Item self) -> Fl_Color\n"
		""},
	 { "Fl_Tree_Item_widget", _wrap_Fl_Tree_Item_widget, METH_VARARGS, "\n"
		"Fl_Tree_Item_widget(Fl_Tree_Item self, Fl_Widget val)\n"
		"Fl_Tree_Item_widget(Fl_Tree_Item self) -> Fl_Widget\n"
		""},
	 { "Fl_Tree_Item_children", _wrap_Fl_Tree_Item_children, METH_O, "Fl_Tree_Item_children(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_child", _wrap_Fl_Tree_Item_child, METH_VARARGS, "\n"
		"Fl_Tree_Item_child(Fl_Tree_Item self, int index) -> Fl_Tree_Item\n"
		"Fl_Tree_Item_child(Fl_Tree_Item self, int t) -> Fl_Tree_Item\n"
		""},
	 { "Fl_Tree_Item_has_children", _wrap_Fl_Tree_Item_has_children, METH_O, "Fl_Tree_Item_has_children(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_find_child", _wrap_Fl_Tree_Item_find_child, METH_VARARGS, "\n"
		"Fl_Tree_Item_find_child(Fl_Tree_Item self, char const * name) -> int\n"
		"Fl_Tree_Item_find_child(Fl_Tree_Item self, Fl_Tree_Item item) -> int\n"
		""},
	 { "Fl_Tree_Item_remove_child", _wrap_Fl_Tree_Item_remove_child, METH_VARARGS, "\n"
		"Fl_Tree_Item_remove_child(Fl_Tree_Item self, Fl_Tree_Item item) -> int\n"
		"Fl_Tree_Item_remove_child(Fl_Tree_Item self, char const * new_label) -> int\n"
		""},
	 { "Fl_Tree_Item_clear_children", _wrap_Fl_Tree_Item_clear_children, METH_O, "Fl_Tree_Item_clear_children(Fl_Tree_Item self)"},
	 { "Fl_Tree_Item_swap_children", _wrap_Fl_Tree_Item_swap_children, METH_VARARGS, "\n"
		"Fl_Tree_Item_swap_children(Fl_Tree_Item self, int ax, int bx)\n"
		"Fl_Tree_Item_swap_children(Fl_Tree_Item self, Fl_Tree_Item a, Fl_Tree_Item b) -> int\n"
		""},
	 { "Fl_Tree_Item_find_child_item", _wrap_Fl_Tree_Item_find_child_item, METH_VARARGS, "\n"
		"Fl_Tree_Item_find_child_item(Fl_Tree_Item self, char const * name) -> Fl_Tree_Item\n"
		"Fl_Tree_Item_find_child_item(Fl_Tree_Item self, char const * name) -> Fl_Tree_Item\n"
		"Fl_Tree_Item_find_child_item(Fl_Tree_Item self, char ** arr) -> Fl_Tree_Item\n"
		"Fl_Tree_Item_find_child_item(Fl_Tree_Item self, char ** arr) -> Fl_Tree_Item\n"
		""},
	 { "Fl_Tree_Item_find_item", _wrap_Fl_Tree_Item_find_item, METH_VARARGS, "\n"
		"Fl_Tree_Item_find_item(Fl_Tree_Item self, char ** arr) -> Fl_Tree_Item\n"
		"Fl_Tree_Item_find_item(Fl_Tree_Item self, char ** arr) -> Fl_Tree_Item\n"
		""},
	 { "Fl_Tree_Item_add", _wrap_Fl_Tree_Item_add, METH_VARARGS, "\n"
		"Fl_Tree_Item_add(Fl_Tree_Item self, Fl_Tree_Prefs prefs, char const * new_label, Fl_Tree_Item newitem) -> Fl_Tree_Item\n"
		"Fl_Tree_Item_add(Fl_Tree_Item self, Fl_Tree_Prefs prefs, char const * new_label) -> Fl_Tree_Item\n"
		"Fl_Tree_Item_add(Fl_Tree_Item self, Fl_Tree_Prefs prefs, char ** arr, Fl_Tree_Item newitem) -> Fl_Tree_Item\n"
		"Fl_Tree_Item_add(Fl_Tree_Item self, Fl_Tree_Prefs prefs, char ** arr) -> Fl_Tree_Item\n"
		""},
	 { "Fl_Tree_Item_replace", _wrap_Fl_Tree_Item_replace, METH_VARARGS, "Fl_Tree_Item_replace(Fl_Tree_Item self, Fl_Tree_Item new_item) -> Fl_Tree_Item"},
	 { "Fl_Tree_Item_replace_child", _wrap_Fl_Tree_Item_replace_child, METH_VARARGS, "Fl_Tree_Item_replace_child(Fl_Tree_Item self, Fl_Tree_Item olditem, Fl_Tree_Item newitem) -> Fl_Tree_Item"},
	 { "Fl_Tree_Item_insert", _wrap_Fl_Tree_Item_insert, METH_VARARGS, "Fl_Tree_Item_insert(Fl_Tree_Item self, Fl_Tree_Prefs prefs, char const * new_label, int pos=0) -> Fl_Tree_Item"},
	 { "Fl_Tree_Item_insert_above", _wrap_Fl_Tree_Item_insert_above, METH_VARARGS, "Fl_Tree_Item_insert_above(Fl_Tree_Item self, Fl_Tree_Prefs prefs, char const * new_label) -> Fl_Tree_Item"},
	 { "Fl_Tree_Item_deparent", _wrap_Fl_Tree_Item_deparent, METH_VARARGS, "Fl_Tree_Item_deparent(Fl_Tree_Item self, int index) -> Fl_Tree_Item"},
	 { "Fl_Tree_Item_reparent", _wrap_Fl_Tree_Item_reparent, METH_VARARGS, "Fl_Tree_Item_reparent(Fl_Tree_Item self, Fl_Tree_Item newchild, int index) -> int"},
	 { "Fl_Tree_Item_move", _wrap_Fl_Tree_Item_move, METH_VARARGS, "\n"
		"Fl_Tree_Item_move(Fl_Tree_Item self, int to, int _from) -> int\n"
		"Fl_Tree_Item_move(Fl_Tree_Item self, Fl_Tree_Item item, int op=0, int pos=0) -> int\n"
		""},
	 { "Fl_Tree_Item_move_above", _wrap_Fl_Tree_Item_move_above, METH_VARARGS, "Fl_Tree_Item_move_above(Fl_Tree_Item self, Fl_Tree_Item item) -> int"},
	 { "Fl_Tree_Item_move_below", _wrap_Fl_Tree_Item_move_below, METH_VARARGS, "Fl_Tree_Item_move_below(Fl_Tree_Item self, Fl_Tree_Item item) -> int"},
	 { "Fl_Tree_Item_move_into", _wrap_Fl_Tree_Item_move_into, METH_VARARGS, "Fl_Tree_Item_move_into(Fl_Tree_Item self, Fl_Tree_Item item, int pos=0) -> int"},
	 { "Fl_Tree_Item_depth", _wrap_Fl_Tree_Item_depth, METH_O, "Fl_Tree_Item_depth(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_prev", _wrap_Fl_Tree_Item_prev, METH_O, "Fl_Tree_Item_prev(Fl_Tree_Item self) -> Fl_Tree_Item"},
	 { "Fl_Tree_Item_next", _wrap_Fl_Tree_Item_next, METH_O, "Fl_Tree_Item_next(Fl_Tree_Item self) -> Fl_Tree_Item"},
	 { "Fl_Tree_Item_next_sibling", _wrap_Fl_Tree_Item_next_sibling, METH_O, "Fl_Tree_Item_next_sibling(Fl_Tree_Item self) -> Fl_Tree_Item"},
	 { "Fl_Tree_Item_prev_sibling", _wrap_Fl_Tree_Item_prev_sibling, METH_O, "Fl_Tree_Item_prev_sibling(Fl_Tree_Item self) -> Fl_Tree_Item"},
	 { "Fl_Tree_Item_update_prev_next", _wrap_Fl_Tree_Item_update_prev_next, METH_VARARGS, "Fl_Tree_Item_update_prev_next(Fl_Tree_Item self, int index)"},
	 { "Fl_Tree_Item_next_displayed", _wrap_Fl_Tree_Item_next_displayed, METH_VARARGS, "Fl_Tree_Item_next_displayed(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> Fl_Tree_Item"},
	 { "Fl_Tree_Item_prev_displayed", _wrap_Fl_Tree_Item_prev_displayed, METH_VARARGS, "Fl_Tree_Item_prev_displayed(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> Fl_Tree_Item"},
	 { "Fl_Tree_Item_next_visible", _wrap_Fl_Tree_Item_next_visible, METH_VARARGS, "Fl_Tree_Item_next_visible(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> Fl_Tree_Item"},
	 { "Fl_Tree_Item_prev_visible", _wrap_Fl_Tree_Item_prev_visible, METH_VARARGS, "Fl_Tree_Item_prev_visible(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> Fl_Tree_Item"},
	 { "Fl_Tree_Item_parent", _wrap_Fl_Tree_Item_parent, METH_VARARGS, "\n"
		"Fl_Tree_Item_parent(Fl_Tree_Item self) -> Fl_Tree_Item\n"
		"Fl_Tree_Item_parent(Fl_Tree_Item self) -> Fl_Tree_Item\n"
		"Fl_Tree_Item_parent(Fl_Tree_Item self, Fl_Tree_Item val)\n"
		""},
	 { "Fl_Tree_Item_prefs", _wrap_Fl_Tree_Item_prefs, METH_O, "Fl_Tree_Item_prefs(Fl_Tree_Item self) -> Fl_Tree_Prefs"},
	 { "Fl_Tree_Item_tree", _wrap_Fl_Tree_Item_tree, METH_VARARGS, "\n"
		"Fl_Tree_Item_tree(Fl_Tree_Item self) -> Fl_Tree\n"
		"Fl_Tree_Item_tree(Fl_Tree_Item self) -> Fl_Tree\n"
		""},
	 { "Fl_Tree_Item_open", _wrap_Fl_Tree_Item_open, METH_O, "Fl_Tree_Item_open(Fl_Tree_Item self)"},
	 { "Fl_Tree_Item_close", _wrap_Fl_Tree_Item_close, METH_O, "Fl_Tree_Item_close(Fl_Tree_Item self)"},
	 { "Fl_Tree_Item_is_open", _wrap_Fl_Tree_Item_is_open, METH_O, "Fl_Tree_Item_is_open(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_is_close", _wrap_Fl_Tree_Item_is_close, METH_O, "Fl_Tree_Item_is_close(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_open_toggle", _wrap_Fl_Tree_Item_open_toggle, METH_O, "Fl_Tree_Item_open_toggle(Fl_Tree_Item self)"},
	 { "Fl_Tree_Item_select", _wrap_Fl_Tree_Item_select, METH_VARARGS, "Fl_Tree_Item_select(Fl_Tree_Item self, int val=1)"},
	 { "Fl_Tree_Item_select_toggle", _wrap_Fl_Tree_Item_select_toggle, METH_O, "Fl_Tree_Item_select_toggle(Fl_Tree_Item self)"},
	 { "Fl_Tree_Item_select_all", _wrap_Fl_Tree_Item_select_all, METH_O, "Fl_Tree_Item_select_all(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_deselect", _wrap_Fl_Tree_Item_deselect, METH_O, "Fl_Tree_Item_deselect(Fl_Tree_Item self)"},
	 { "Fl_Tree_Item_deselect_all", _wrap_Fl_Tree_Item_deselect_all, METH_O, "Fl_Tree_Item_deselect_all(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_is_selected", _wrap_Fl_Tree_Item_is_selected, METH_O, "Fl_Tree_Item_is_selected(Fl_Tree_Item self) -> char"},
	 { "Fl_Tree_Item_activate", _wrap_Fl_Tree_Item_activate, METH_VARARGS, "Fl_Tree_Item_activate(Fl_Tree_Item self, int val=1)"},
	 { "Fl_Tree_Item_deactivate", _wrap_Fl_Tree_Item_deactivate, METH_O, "Fl_Tree_Item_deactivate(Fl_Tree_Item self)"},
	 { "Fl_Tree_Item_is_activated", _wrap_Fl_Tree_Item_is_activated, METH_O, "Fl_Tree_Item_is_activated(Fl_Tree_Item self) -> char"},
	 { "Fl_Tree_Item_is_active", _wrap_Fl_Tree_Item_is_active, METH_O, "Fl_Tree_Item_is_active(Fl_Tree_Item self) -> char"},
	 { "Fl_Tree_Item_visible", _wrap_Fl_Tree_Item_visible, METH_O, "Fl_Tree_Item_visible(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_is_visible", _wrap_Fl_Tree_Item_is_visible, METH_O, "Fl_Tree_Item_is_visible(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_visible_r", _wrap_Fl_Tree_Item_visible_r, METH_O, "Fl_Tree_Item_visible_r(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_is_visible_r", _wrap_Fl_Tree_Item_is_visible_r, METH_O, "Fl_Tree_Item_is_visible_r(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_usericon", _wrap_Fl_Tree_Item_usericon, METH_VARARGS, "\n"
		"Fl_Tree_Item_usericon(Fl_Tree_Item self, Fl_Image val)\n"
		"Fl_Tree_Item_usericon(Fl_Tree_Item self) -> Fl_Image\n"
		""},
	 { "Fl_Tree_Item_userdeicon", _wrap_Fl_Tree_Item_userdeicon, METH_VARARGS, "\n"
		"Fl_Tree_Item_userdeicon(Fl_Tree_Item self, Fl_Image val)\n"
		"Fl_Tree_Item_userdeicon(Fl_Tree_Item self) -> Fl_Image\n"
		""},
	 { "Fl_Tree_Item_find_clicked", _wrap_Fl_Tree_Item_find_clicked, METH_VARARGS, "\n"
		"Fl_Tree_Item_find_clicked(Fl_Tree_Item self, Fl_Tree_Prefs prefs, int yonly=0) -> Fl_Tree_Item\n"
		"Fl_Tree_Item_find_clicked(Fl_Tree_Item self, Fl_Tree_Prefs prefs, int yonly=0) -> Fl_Tree_Item\n"
		""},
	 { "Fl_Tree_Item_event_on_item", _wrap_Fl_Tree_Item_event_on_item, METH_VARARGS, "Fl_Tree_Item_event_on_item(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> int"},
	 { "Fl_Tree_Item_event_on_collapse_icon", _wrap_Fl_Tree_Item_event_on_collapse_icon, METH_VARARGS, "Fl_Tree_Item_event_on_collapse_icon(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> int"},
	 { "Fl_Tree_Item_event_on_user_icon", _wrap_Fl_Tree_Item_event_on_user_icon, METH_VARARGS, "Fl_Tree_Item_event_on_user_icon(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> int"},
	 { "Fl_Tree_Item_event_on_label", _wrap_Fl_Tree_Item_event_on_label, METH_VARARGS, "Fl_Tree_Item_event_on_label(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> int"},
	 { "Fl_Tree_Item_is_root", _wrap_Fl_Tree_Item_is_root, METH_O, "Fl_Tree_Item_is_root(Fl_Tree_Item self) -> int"},
	 { "Fl_Tree_Item_init_type", _wrap_Fl_Tree_Item_init_type, METH_VARARGS, "Fl_Tree_Item_init_type(Fl_Tree_Item self, char * Fl_Tree_Item)"},
	 { "Fl_Tree_Item_user_data", _wrap_Fl_Tree_Item_user_data, METH_VARARGS, "\n"
		"Fl_Tree_Item_user_data(Fl_Tree_Item self, PyObject * PyData)\n"
		"Fl_Tree_Item_user_data(Fl_Tree_Item self) -> PyObject *\n"
		""},
	 { "disown_Fl_Tree_Item", _wrap_disown_Fl_Tree_Item, METH_O, NULL},
	 { "Fl_Tree_Item_swigregister", Fl_Tree_Item_swigregister, METH_O, NULL},
	 { "Fl_Tree_Item_swiginit", Fl_Tree_Item_swiginit, METH_VARARGS, NULL},
	 { "Fl_Tree_draw", _wrap_Fl_Tree_draw, METH_O, "Fl_Tree_draw(Fl_Tree self)"},
	 { "new_Fl_Tree", _wrap_new_Fl_Tree, METH_VARARGS, "new_Fl_Tree(PyObject * _self, int X, int Y, int W, int H, char const * L=None) -> Fl_Tree"},
	 { "delete_Fl_Tree", _wrap_delete_Fl_Tree, METH_O, "delete_Fl_Tree(Fl_Tree self)"},
	 { "Fl_Tree_handle", _wrap_Fl_Tree_handle, METH_VARARGS, "Fl_Tree_handle(Fl_Tree self, int e) -> int"},
	 { "Fl_Tree_show_self", _wrap_Fl_Tree_show_self, METH_O, "Fl_Tree_show_self(Fl_Tree self)"},
	 { "Fl_Tree_resize", _wrap_Fl_Tree_resize, METH_VARARGS, "Fl_Tree_resize(Fl_Tree self, int arg0, int arg1, int arg2, int arg3)"},
	 { "Fl_Tree_root_label", _wrap_Fl_Tree_root_label, METH_VARARGS, "Fl_Tree_root_label(Fl_Tree self, char const * new_label)"},
	 { "Fl_Tree_root", _wrap_Fl_Tree_root, METH_VARARGS, "\n"
		"Fl_Tree_root(Fl_Tree self) -> Fl_Tree_Item\n"
		"Fl_Tree_root(Fl_Tree self, Fl_Tree_Item newitem)\n"
		""},
	 { "Fl_Tree_prefs", _wrap_Fl_Tree_prefs, METH_O, "Fl_Tree_prefs(Fl_Tree self) -> Fl_Tree_Prefs"},
	 { "Fl_Tree_add", _wrap_Fl_Tree_add, METH_VARARGS, "\n"
		"Fl_Tree_add(Fl_Tree self, char const * path, Fl_Tree_Item newitem=None) -> Fl_Tree_Item\n"
		"Fl_Tree_add(Fl_Tree self, Fl_Tree_Item parent_item, char const * name) -> Fl_Tree_Item\n"
		""},
	 { "Fl_Tree_insert_above", _wrap_Fl_Tree_insert_above, METH_VARARGS, "Fl_Tree_insert_above(Fl_Tree self, Fl_Tree_Item above, char const * name) -> Fl_Tree_Item"},
	 { "Fl_Tree_insert", _wrap_Fl_Tree_insert, METH_VARARGS, "Fl_Tree_insert(Fl_Tree self, Fl_Tree_Item item, char const * name, int pos) -> Fl_Tree_Item"},
	 { "Fl_Tree_remove", _wrap_Fl_Tree_remove, METH_VARARGS, "Fl_Tree_remove(Fl_Tree self, Fl_Tree_Item item) -> int"},
	 { "Fl_Tree_clear", _wrap_Fl_Tree_clear, METH_O, "Fl_Tree_clear(Fl_Tree self)"},
	 { "Fl_Tree_clear_children", _wrap_Fl_Tree_clear_children, METH_VARARGS, "Fl_Tree_clear_children(Fl_Tree self, Fl_Tree_Item item)"},
	 { "Fl_Tree_find_item", _wrap_Fl_Tree_find_item, METH_VARARGS, "\n"
		"Fl_Tree_find_item(Fl_Tree self, char const * path) -> Fl_Tree_Item\n"
		"Fl_Tree_find_item(Fl_Tree self, char const * path) -> Fl_Tree_Item\n"
		""},
	 { "Fl_Tree_item_pathname", _wrap_Fl_Tree_item_pathname, METH_VARARGS, "Fl_Tree_item_pathname(Fl_Tree self, char * pathname, int pathnamelen, Fl_Tree_Item item) -> int"},
	 { "Fl_Tree_find_clicked", _wrap_Fl_Tree_find_clicked, METH_VARARGS, "\n"
		"Fl_Tree_find_clicked(Fl_Tree self, int yonly=0) -> Fl_Tree_Item\n"
		"Fl_Tree_find_clicked(Fl_Tree self, int yonly=0) -> Fl_Tree_Item\n"
		""},
	 { "Fl_Tree_item_clicked", _wrap_Fl_Tree_item_clicked, METH_O, "Fl_Tree_item_clicked(Fl_Tree self) -> Fl_Tree_Item"},
	 { "Fl_Tree_first", _wrap_Fl_Tree_first, METH_O, "Fl_Tree_first(Fl_Tree self) -> Fl_Tree_Item"},
	 { "Fl_Tree_first_visible", _wrap_Fl_Tree_first_visible, METH_O, "Fl_Tree_first_visible(Fl_Tree self) -> Fl_Tree_Item"},
	 { "Fl_Tree_first_visible_item", _wrap_Fl_Tree_first_visible_item, METH_O, "Fl_Tree_first_visible_item(Fl_Tree self) -> Fl_Tree_Item"},
	 { "Fl_Tree_next", _wrap_Fl_Tree_next, METH_VARARGS, "Fl_Tree_next(Fl_Tree self, Fl_Tree_Item item=None) -> Fl_Tree_Item"},
	 { "Fl_Tree_prev", _wrap_Fl_Tree_prev, METH_VARARGS, "Fl_Tree_prev(Fl_Tree self, Fl_Tree_Item item=None) -> Fl_Tree_Item"},
	 { "Fl_Tree_last", _wrap_Fl_Tree_last, METH_O, "Fl_Tree_last(Fl_Tree self) -> Fl_Tree_Item"},
	 { "Fl_Tree_last_visible", _wrap_Fl_Tree_last_visible, METH_O, "Fl_Tree_last_visible(Fl_Tree self) -> Fl_Tree_Item"},
	 { "Fl_Tree_last_visible_item", _wrap_Fl_Tree_last_visible_item, METH_O, "Fl_Tree_last_visible_item(Fl_Tree self) -> Fl_Tree_Item"},
	 { "Fl_Tree_next_visible_item", _wrap_Fl_Tree_next_visible_item, METH_VARARGS, "Fl_Tree_next_visible_item(Fl_Tree self, Fl_Tree_Item start, int dir) -> Fl_Tree_Item"},
	 { "Fl_Tree_first_selected_item", _wrap_Fl_Tree_first_selected_item, METH_O, "Fl_Tree_first_selected_item(Fl_Tree self) -> Fl_Tree_Item"},
	 { "Fl_Tree_last_selected_item", _wrap_Fl_Tree_last_selected_item, METH_O, "Fl_Tree_last_selected_item(Fl_Tree self) -> Fl_Tree_Item"},
	 { "Fl_Tree_next_item", _wrap_Fl_Tree_next_item, METH_VARARGS, "Fl_Tree_next_item(Fl_Tree self, Fl_Tree_Item item, int dir=65364, bool visible=False) -> Fl_Tree_Item"},
	 { "Fl_Tree_next_selected_item", _wrap_Fl_Tree_next_selected_item, METH_VARARGS, "Fl_Tree_next_selected_item(Fl_Tree self, Fl_Tree_Item item=None, int dir=65364) -> Fl_Tree_Item"},
	 { "Fl_Tree_get_selected_items", _wrap_Fl_Tree_get_selected_items, METH_VARARGS, "Fl_Tree_get_selected_items(Fl_Tree self, Fl_Tree_Item_Array items) -> int"},
	 { "Fl_Tree_open", _wrap_Fl_Tree_open, METH_VARARGS, "\n"
		"Fl_Tree_open(Fl_Tree self, Fl_Tree_Item item, int docallback=1) -> int\n"
		"Fl_Tree_open(Fl_Tree self, char const * path, int docallback=1) -> int\n"
		""},
	 { "Fl_Tree_open_toggle", _wrap_Fl_Tree_open_toggle, METH_VARARGS, "Fl_Tree_open_toggle(Fl_Tree self, Fl_Tree_Item item, int docallback=1)"},
	 { "Fl_Tree_close", _wrap_Fl_Tree_close, METH_VARARGS, "\n"
		"Fl_Tree_close(Fl_Tree self, Fl_Tree_Item item, int docallback=1) -> int\n"
		"Fl_Tree_close(Fl_Tree self, char const * path, int docallback=1) -> int\n"
		""},
	 { "Fl_Tree_is_open", _wrap_Fl_Tree_is_open, METH_VARARGS, "\n"
		"Fl_Tree_is_open(Fl_Tree self, Fl_Tree_Item item) -> int\n"
		"Fl_Tree_is_open(Fl_Tree self, char const * path) -> int\n"
		""},
	 { "Fl_Tree_is_close", _wrap_Fl_Tree_is_close, METH_VARARGS, "\n"
		"Fl_Tree_is_close(Fl_Tree self, Fl_Tree_Item item) -> int\n"
		"Fl_Tree_is_close(Fl_Tree self, char const * path) -> int\n"
		""},
	 { "Fl_Tree_select", _wrap_Fl_Tree_select, METH_VARARGS, "\n"
		"Fl_Tree_select(Fl_Tree self, Fl_Tree_Item item, int docallback=1) -> int\n"
		"Fl_Tree_select(Fl_Tree self, char const * path, int docallback=1) -> int\n"
		""},
	 { "Fl_Tree_select_toggle", _wrap_Fl_Tree_select_toggle, METH_VARARGS, "Fl_Tree_select_toggle(Fl_Tree self, Fl_Tree_Item item, int docallback=1)"},
	 { "Fl_Tree_deselect", _wrap_Fl_Tree_deselect, METH_VARARGS, "\n"
		"Fl_Tree_deselect(Fl_Tree self, Fl_Tree_Item item, int docallback=1) -> int\n"
		"Fl_Tree_deselect(Fl_Tree self, char const * path, int docallback=1) -> int\n"
		""},
	 { "Fl_Tree_deselect_all", _wrap_Fl_Tree_deselect_all, METH_VARARGS, "Fl_Tree_deselect_all(Fl_Tree self, Fl_Tree_Item item=None, int docallback=1) -> int"},
	 { "Fl_Tree_select_only", _wrap_Fl_Tree_select_only, METH_VARARGS, "Fl_Tree_select_only(Fl_Tree self, Fl_Tree_Item selitem, int docallback=1) -> int"},
	 { "Fl_Tree_select_all", _wrap_Fl_Tree_select_all, METH_VARARGS, "Fl_Tree_select_all(Fl_Tree self, Fl_Tree_Item item=None, int docallback=1) -> int"},
	 { "Fl_Tree_extend_selection_dir", _wrap_Fl_Tree_extend_selection_dir, METH_VARARGS, "Fl_Tree_extend_selection_dir(Fl_Tree self, Fl_Tree_Item _from, Fl_Tree_Item to, int dir, int val, bool visible) -> int"},
	 { "Fl_Tree_extend_selection", _wrap_Fl_Tree_extend_selection, METH_VARARGS, "Fl_Tree_extend_selection(Fl_Tree self, Fl_Tree_Item _from, Fl_Tree_Item to, int val=1, bool visible=False) -> int"},
	 { "Fl_Tree_set_item_focus", _wrap_Fl_Tree_set_item_focus, METH_VARARGS, "Fl_Tree_set_item_focus(Fl_Tree self, Fl_Tree_Item item)"},
	 { "Fl_Tree_get_item_focus", _wrap_Fl_Tree_get_item_focus, METH_O, "Fl_Tree_get_item_focus(Fl_Tree self) -> Fl_Tree_Item"},
	 { "Fl_Tree_is_selected", _wrap_Fl_Tree_is_selected, METH_VARARGS, "\n"
		"Fl_Tree_is_selected(Fl_Tree self, Fl_Tree_Item item) -> int\n"
		"Fl_Tree_is_selected(Fl_Tree self, char const * path) -> int\n"
		""},
	 { "Fl_Tree_item_labelfont", _wrap_Fl_Tree_item_labelfont, METH_VARARGS, "\n"
		"Fl_Tree_item_labelfont(Fl_Tree self) -> Fl_Font\n"
		"Fl_Tree_item_labelfont(Fl_Tree self, Fl_Font val)\n"
		""},
	 { "Fl_Tree_item_labelsize", _wrap_Fl_Tree_item_labelsize, METH_VARARGS, "\n"
		"Fl_Tree_item_labelsize(Fl_Tree self) -> Fl_Fontsize\n"
		"Fl_Tree_item_labelsize(Fl_Tree self, Fl_Fontsize val)\n"
		""},
	 { "Fl_Tree_item_labelfgcolor", _wrap_Fl_Tree_item_labelfgcolor, METH_VARARGS, "\n"
		"Fl_Tree_item_labelfgcolor(Fl_Tree self) -> Fl_Color\n"
		"Fl_Tree_item_labelfgcolor(Fl_Tree self, Fl_Color val)\n"
		""},
	 { "Fl_Tree_item_labelbgcolor", _wrap_Fl_Tree_item_labelbgcolor, METH_VARARGS, "\n"
		"Fl_Tree_item_labelbgcolor(Fl_Tree self) -> Fl_Color\n"
		"Fl_Tree_item_labelbgcolor(Fl_Tree self, Fl_Color val)\n"
		""},
	 { "Fl_Tree_connectorcolor", _wrap_Fl_Tree_connectorcolor, METH_VARARGS, "\n"
		"Fl_Tree_connectorcolor(Fl_Tree self) -> Fl_Color\n"
		"Fl_Tree_connectorcolor(Fl_Tree self, Fl_Color val)\n"
		""},
	 { "Fl_Tree_marginleft", _wrap_Fl_Tree_marginleft, METH_VARARGS, "\n"
		"Fl_Tree_marginleft(Fl_Tree self) -> int\n"
		"Fl_Tree_marginleft(Fl_Tree self, int val)\n"
		""},
	 { "Fl_Tree_margintop", _wrap_Fl_Tree_margintop, METH_VARARGS, "\n"
		"Fl_Tree_margintop(Fl_Tree self) -> int\n"
		"Fl_Tree_margintop(Fl_Tree self, int val)\n"
		""},
	 { "Fl_Tree_marginbottom", _wrap_Fl_Tree_marginbottom, METH_VARARGS, "\n"
		"Fl_Tree_marginbottom(Fl_Tree self) -> int\n"
		"Fl_Tree_marginbottom(Fl_Tree self, int val)\n"
		""},
	 { "Fl_Tree_linespacing", _wrap_Fl_Tree_linespacing, METH_VARARGS, "\n"
		"Fl_Tree_linespacing(Fl_Tree self) -> int\n"
		"Fl_Tree_linespacing(Fl_Tree self, int val)\n"
		""},
	 { "Fl_Tree_openchild_marginbottom", _wrap_Fl_Tree_openchild_marginbottom, METH_VARARGS, "\n"
		"Fl_Tree_openchild_marginbottom(Fl_Tree self) -> int\n"
		"Fl_Tree_openchild_marginbottom(Fl_Tree self, int val)\n"
		""},
	 { "Fl_Tree_usericonmarginleft", _wrap_Fl_Tree_usericonmarginleft, METH_VARARGS, "\n"
		"Fl_Tree_usericonmarginleft(Fl_Tree self) -> int\n"
		"Fl_Tree_usericonmarginleft(Fl_Tree self, int val)\n"
		""},
	 { "Fl_Tree_labelmarginleft", _wrap_Fl_Tree_labelmarginleft, METH_VARARGS, "\n"
		"Fl_Tree_labelmarginleft(Fl_Tree self) -> int\n"
		"Fl_Tree_labelmarginleft(Fl_Tree self, int val)\n"
		""},
	 { "Fl_Tree_widgetmarginleft", _wrap_Fl_Tree_widgetmarginleft, METH_VARARGS, "\n"
		"Fl_Tree_widgetmarginleft(Fl_Tree self) -> int\n"
		"Fl_Tree_widgetmarginleft(Fl_Tree self, int val)\n"
		""},
	 { "Fl_Tree_connectorwidth", _wrap_Fl_Tree_connectorwidth, METH_VARARGS, "\n"
		"Fl_Tree_connectorwidth(Fl_Tree self) -> int\n"
		"Fl_Tree_connectorwidth(Fl_Tree self, int val)\n"
		""},
	 { "Fl_Tree_usericon", _wrap_Fl_Tree_usericon, METH_VARARGS, "\n"
		"Fl_Tree_usericon(Fl_Tree self) -> Fl_Image\n"
		"Fl_Tree_usericon(Fl_Tree self, Fl_Image val)\n"
		""},
	 { "Fl_Tree_openicon", _wrap_Fl_Tree_openicon, METH_VARARGS, "\n"
		"Fl_Tree_openicon(Fl_Tree self) -> Fl_Image\n"
		"Fl_Tree_openicon(Fl_Tree self, Fl_Image val)\n"
		""},
	 { "Fl_Tree_closeicon", _wrap_Fl_Tree_closeicon, METH_VARARGS, "\n"
		"Fl_Tree_closeicon(Fl_Tree self) -> Fl_Image\n"
		"Fl_Tree_closeicon(Fl_Tree self, Fl_Image val)\n"
		""},
	 { "Fl_Tree_showcollapse", _wrap_Fl_Tree_showcollapse, METH_VARARGS, "\n"
		"Fl_Tree_showcollapse(Fl_Tree self) -> int\n"
		"Fl_Tree_showcollapse(Fl_Tree self, int val)\n"
		""},
	 { "Fl_Tree_showroot", _wrap_Fl_Tree_showroot, METH_VARARGS, "\n"
		"Fl_Tree_showroot(Fl_Tree self) -> int\n"
		"Fl_Tree_showroot(Fl_Tree self, int val)\n"
		""},
	 { "Fl_Tree_connectorstyle", _wrap_Fl_Tree_connectorstyle, METH_VARARGS, "\n"
		"Fl_Tree_connectorstyle(Fl_Tree self) -> Fl_Tree_Connector\n"
		"Fl_Tree_connectorstyle(Fl_Tree self, Fl_Tree_Connector val)\n"
		""},
	 { "Fl_Tree_sortorder", _wrap_Fl_Tree_sortorder, METH_VARARGS, "\n"
		"Fl_Tree_sortorder(Fl_Tree self) -> Fl_Tree_Sort\n"
		"Fl_Tree_sortorder(Fl_Tree self, Fl_Tree_Sort val)\n"
		""},
	 { "Fl_Tree_selectbox", _wrap_Fl_Tree_selectbox, METH_VARARGS, "\n"
		"Fl_Tree_selectbox(Fl_Tree self) -> Fl_Boxtype\n"
		"Fl_Tree_selectbox(Fl_Tree self, Fl_Boxtype val)\n"
		""},
	 { "Fl_Tree_selectmode", _wrap_Fl_Tree_selectmode, METH_VARARGS, "\n"
		"Fl_Tree_selectmode(Fl_Tree self) -> Fl_Tree_Select\n"
		"Fl_Tree_selectmode(Fl_Tree self, Fl_Tree_Select val)\n"
		""},
	 { "Fl_Tree_item_reselect_mode", _wrap_Fl_Tree_item_reselect_mode, METH_VARARGS, "\n"
		"Fl_Tree_item_reselect_mode(Fl_Tree self) -> Fl_Tree_Item_Reselect_Mode\n"
		"Fl_Tree_item_reselect_mode(Fl_Tree self, Fl_Tree_Item_Reselect_Mode mode)\n"
		""},
	 { "Fl_Tree_item_draw_mode", _wrap_Fl_Tree_item_draw_mode, METH_VARARGS, "\n"
		"Fl_Tree_item_draw_mode(Fl_Tree self) -> Fl_Tree_Item_Draw_Mode\n"
		"Fl_Tree_item_draw_mode(Fl_Tree self, Fl_Tree_Item_Draw_Mode mode)\n"
		"Fl_Tree_item_draw_mode(Fl_Tree self, int mode)\n"
		""},
	 { "Fl_Tree_calc_dimensions", _wrap_Fl_Tree_calc_dimensions, METH_O, "Fl_Tree_calc_dimensions(Fl_Tree self)"},
	 { "Fl_Tree_calc_tree", _wrap_Fl_Tree_calc_tree, METH_O, "Fl_Tree_calc_tree(Fl_Tree self)"},
	 { "Fl_Tree_recalc_tree", _wrap_Fl_Tree_recalc_tree, METH_O, "Fl_Tree_recalc_tree(Fl_Tree self)"},
	 { "Fl_Tree_displayed", _wrap_Fl_Tree_displayed, METH_VARARGS, "Fl_Tree_displayed(Fl_Tree self, Fl_Tree_Item item) -> int"},
	 { "Fl_Tree_show_item", _wrap_Fl_Tree_show_item, METH_VARARGS, "\n"
		"Fl_Tree_show_item(Fl_Tree self, Fl_Tree_Item item, int yoff)\n"
		"Fl_Tree_show_item(Fl_Tree self, Fl_Tree_Item item)\n"
		""},
	 { "Fl_Tree_show_item_top", _wrap_Fl_Tree_show_item_top, METH_VARARGS, "Fl_Tree_show_item_top(Fl_Tree self, Fl_Tree_Item item)"},
	 { "Fl_Tree_show_item_middle", _wrap_Fl_Tree_show_item_middle, METH_VARARGS, "Fl_Tree_show_item_middle(Fl_Tree self, Fl_Tree_Item item)"},
	 { "Fl_Tree_show_item_bottom", _wrap_Fl_Tree_show_item_bottom, METH_VARARGS, "Fl_Tree_show_item_bottom(Fl_Tree self, Fl_Tree_Item item)"},
	 { "Fl_Tree_display", _wrap_Fl_Tree_display, METH_VARARGS, "Fl_Tree_display(Fl_Tree self, Fl_Tree_Item item)"},
	 { "Fl_Tree_vposition", _wrap_Fl_Tree_vposition, METH_VARARGS, "\n"
		"Fl_Tree_vposition(Fl_Tree self) -> int\n"
		"Fl_Tree_vposition(Fl_Tree self, int pos)\n"
		""},
	 { "Fl_Tree_hposition", _wrap_Fl_Tree_hposition, METH_VARARGS, "\n"
		"Fl_Tree_hposition(Fl_Tree self) -> int\n"
		"Fl_Tree_hposition(Fl_Tree self, int pos)\n"
		""},
	 { "Fl_Tree_is_scrollbar", _wrap_Fl_Tree_is_scrollbar, METH_VARARGS, "Fl_Tree_is_scrollbar(Fl_Tree self, Fl_Widget w) -> int"},
	 { "Fl_Tree_scrollbar_size", _wrap_Fl_Tree_scrollbar_size, METH_VARARGS, "\n"
		"Fl_Tree_scrollbar_size(Fl_Tree self) -> int\n"
		"Fl_Tree_scrollbar_size(Fl_Tree self, int size)\n"
		""},
	 { "Fl_Tree_is_vscroll_visible", _wrap_Fl_Tree_is_vscroll_visible, METH_O, "Fl_Tree_is_vscroll_visible(Fl_Tree self) -> int"},
	 { "Fl_Tree_is_hscroll_visible", _wrap_Fl_Tree_is_hscroll_visible, METH_O, "Fl_Tree_is_hscroll_visible(Fl_Tree self) -> int"},
	 { "Fl_Tree_callback_item", _wrap_Fl_Tree_callback_item, METH_VARARGS, "\n"
		"Fl_Tree_callback_item(Fl_Tree self, Fl_Tree_Item item)\n"
		"Fl_Tree_callback_item(Fl_Tree self) -> Fl_Tree_Item\n"
		""},
	 { "Fl_Tree_callback_reason", _wrap_Fl_Tree_callback_reason, METH_VARARGS, "\n"
		"Fl_Tree_callback_reason(Fl_Tree self, Fl_Tree_Reason reason)\n"
		"Fl_Tree_callback_reason(Fl_Tree self) -> Fl_Tree_Reason\n"
		""},
	 { "Fl_Tree_load", _wrap_Fl_Tree_load, METH_VARARGS, "Fl_Tree_load(Fl_Tree self, Fl_Preferences arg2)"},
	 { "Fl_Tree_init_type", _wrap_Fl_Tree_init_type, METH_VARARGS, "Fl_Tree_init_type(Fl_Tree self, char * Fl_Tree)"},
	 { "disown_Fl_Tree", _wrap_disown_Fl_Tree, METH_O, NULL},
	 { "Fl_Tree_swigregister", Fl_Tree_swigregister, METH_O, NULL},
	 { "Fl_Tree_swiginit", Fl_Tree_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Paged_Device", _wrap_new_Fl_Paged_Device, METH_O, "new_Fl_Paged_Device(PyObject * _self) -> Fl_Paged_Device"},
	 { "delete_Fl_Paged_Device", _wrap_delete_Fl_Paged_Device, METH_O, "delete_Fl_Paged_Device(Fl_Paged_Device self)"},
	 { "Fl_Paged_Device_begin_job", _wrap_Fl_Paged_Device_begin_job, METH_VARARGS, "Fl_Paged_Device_begin_job(Fl_Paged_Device self, int pagecount=0, int * frompage=None, int * topage=None, char ** perr_message=None) -> int"},
	 { "Fl_Paged_Device_start_job", _wrap_Fl_Paged_Device_start_job, METH_VARARGS, "Fl_Paged_Device_start_job(Fl_Paged_Device self, int pagecount=0, int * frompage=None, int * topage=None, char ** perr_message=None) -> int"},
	 { "Fl_Paged_Device_begin_page", _wrap_Fl_Paged_Device_begin_page, METH_O, "Fl_Paged_Device_begin_page(Fl_Paged_Device self) -> int"},
	 { "Fl_Paged_Device_start_page", _wrap_Fl_Paged_Device_start_page, METH_O, "Fl_Paged_Device_start_page(Fl_Paged_Device self) -> int"},
	 { "Fl_Paged_Device_margins", _wrap_Fl_Paged_Device_margins, METH_VARARGS, "Fl_Paged_Device_margins(Fl_Paged_Device self, int * left, int * top, int * right, int * bottom)"},
	 { "Fl_Paged_Device_scale", _wrap_Fl_Paged_Device_scale, METH_VARARGS, "Fl_Paged_Device_scale(Fl_Paged_Device self, float scale_x, float scale_y=0.)"},
	 { "Fl_Paged_Device_rotate", _wrap_Fl_Paged_Device_rotate, METH_VARARGS, "Fl_Paged_Device_rotate(Fl_Paged_Device self, float angle)"},
	 { "Fl_Paged_Device_print_widget", _wrap_Fl_Paged_Device_print_widget, METH_VARARGS, "Fl_Paged_Device_print_widget(Fl_Paged_Device self, Fl_Widget widget, int delta_x=0, int delta_y=0)"},
	 { "Fl_Paged_Device_print_window", _wrap_Fl_Paged_Device_print_window, METH_VARARGS, "Fl_Paged_Device_print_window(Fl_Paged_Device self, Fl_Window win, int x_off=0, int y_off=0)"},
	 { "Fl_Paged_Device_end_page", _wrap_Fl_Paged_Device_end_page, METH_O, "Fl_Paged_Device_end_page(Fl_Paged_Device self) -> int"},
	 { "Fl_Paged_Device_end_job", _wrap_Fl_Paged_Device_end_job, METH_O, "Fl_Paged_Device_end_job(Fl_Paged_Device self)"},
	 { "disown_Fl_Paged_Device", _wrap_disown_Fl_Paged_Device, METH_O, NULL},
	 { "Fl_Paged_Device_end_current", _wrap_Fl_Paged_Device_end_current, METH_O, "Fl_Paged_Device_end_current(Fl_Paged_Device self)"},
	 { "Fl_Paged_Device_swigregister", Fl_Paged_Device_swigregister, METH_O, NULL},
	 { "Fl_Paged_Device_swiginit", Fl_Paged_Device_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_PDF_File_Surface", _wrap_new_Fl_PDF_File_Surface, METH_O, "new_Fl_PDF_File_Surface(PyObject * _self) -> Fl_PDF_File_Surface"},
	 { "delete_Fl_PDF_File_Surface", _wrap_delete_Fl_PDF_File_Surface, METH_O, "delete_Fl_PDF_File_Surface(Fl_PDF_File_Surface self)"},
	 { "Fl_PDF_File_Surface_begin_job", _wrap_Fl_PDF_File_Surface_begin_job, METH_VARARGS, "\n"
		"Fl_PDF_File_Surface_begin_job(Fl_PDF_File_Surface self, char const * defaultfilename, char ** perr=None) -> int\n"
		"Fl_PDF_File_Surface_begin_job(Fl_PDF_File_Surface self, int arg0, int * arg1, int * arg2, char ** arg3) -> int\n"
		""},
	 { "Fl_PDF_File_Surface_begin_document", _wrap_Fl_PDF_File_Surface_begin_document, METH_VARARGS, "Fl_PDF_File_Surface_begin_document(Fl_PDF_File_Surface self, char const * pathname, enum Fl_Paged_Device::Page_Format format=A4, enum Fl_Paged_Device::Page_Layout layout=PORTRAIT, char ** perr=None) -> int"},
	 { "Fl_PDF_File_Surface_printable_rect", _wrap_Fl_PDF_File_Surface_printable_rect, METH_O, "Fl_PDF_File_Surface_printable_rect(Fl_PDF_File_Surface self) -> int"},
	 { "Fl_PDF_File_Surface_margins", _wrap_Fl_PDF_File_Surface_margins, METH_O, "Fl_PDF_File_Surface_margins(Fl_PDF_File_Surface self)"},
	 { "Fl_PDF_File_Surface_origin", _wrap_Fl_PDF_File_Surface_origin, METH_VARARGS, "\n"
		"Fl_PDF_File_Surface_origin(Fl_PDF_File_Surface self, int x, int y)\n"
		"Fl_PDF_File_Surface_origin(Fl_PDF_File_Surface self)\n"
		""},
	 { "Fl_PDF_File_Surface_scale", _wrap_Fl_PDF_File_Surface_scale, METH_VARARGS, "Fl_PDF_File_Surface_scale(Fl_PDF_File_Surface self, float s_x, float s_y=0)"},
	 { "Fl_PDF_File_Surface_rotate", _wrap_Fl_PDF_File_Surface_rotate, METH_VARARGS, "Fl_PDF_File_Surface_rotate(Fl_PDF_File_Surface self, float angle)"},
	 { "Fl_PDF_File_Surface_translate", _wrap_Fl_PDF_File_Surface_translate, METH_VARARGS, "Fl_PDF_File_Surface_translate(Fl_PDF_File_Surface self, int x, int y)"},
	 { "Fl_PDF_File_Surface_untranslate", _wrap_Fl_PDF_File_Surface_untranslate, METH_O, "Fl_PDF_File_Surface_untranslate(Fl_PDF_File_Surface self)"},
	 { "Fl_PDF_File_Surface_begin_page", _wrap_Fl_PDF_File_Surface_begin_page, METH_O, "Fl_PDF_File_Surface_begin_page(Fl_PDF_File_Surface self) -> int"},
	 { "Fl_PDF_File_Surface_end_page", _wrap_Fl_PDF_File_Surface_end_page, METH_O, "Fl_PDF_File_Surface_end_page(Fl_PDF_File_Surface self) -> int"},
	 { "Fl_PDF_File_Surface_end_job", _wrap_Fl_PDF_File_Surface_end_job, METH_O, "Fl_PDF_File_Surface_end_job(Fl_PDF_File_Surface self)"},
	 { "Fl_PDF_File_Surface_pdf_filename", _wrap_Fl_PDF_File_Surface_pdf_filename, METH_O, "Fl_PDF_File_Surface_pdf_filename(Fl_PDF_File_Surface self) -> char const *"},
	 { "Fl_PDF_File_Surface_set_current", _wrap_Fl_PDF_File_Surface_set_current, METH_O, "Fl_PDF_File_Surface_set_current(Fl_PDF_File_Surface self)"},
	 { "Fl_PDF_File_Surface_is_current", _wrap_Fl_PDF_File_Surface_is_current, METH_O, "Fl_PDF_File_Surface_is_current(Fl_PDF_File_Surface self) -> bool"},
	 { "disown_Fl_PDF_File_Surface", _wrap_disown_Fl_PDF_File_Surface, METH_O, NULL},
	 { "Fl_PDF_File_Surface_end_current", _wrap_Fl_PDF_File_Surface_end_current, METH_O, "Fl_PDF_File_Surface_end_current(Fl_PDF_File_Surface self)"},
	 { "Fl_PDF_File_Surface_swigregister", Fl_PDF_File_Surface_swigregister, METH_O, NULL},
	 { "Fl_PDF_File_Surface_swiginit", Fl_PDF_File_Surface_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_PostScript_File_Device", _wrap_new_Fl_PostScript_File_Device, METH_O, "new_Fl_PostScript_File_Device(PyObject * _self) -> Fl_PostScript_File_Device"},
	 { "delete_Fl_PostScript_File_Device", _wrap_delete_Fl_PostScript_File_Device, METH_O, "delete_Fl_PostScript_File_Device(Fl_PostScript_File_Device self)"},
	 { "Fl_PostScript_File_Device_begin_job", _wrap_Fl_PostScript_File_Device_begin_job, METH_VARARGS, "\n"
		"Fl_PostScript_File_Device_begin_job(Fl_PostScript_File_Device self, int pagecount, int * _from, int * to, char ** perr_message) -> int\n"
		"Fl_PostScript_File_Device_begin_job(Fl_PostScript_File_Device self, int pagecount=0, enum Fl_Paged_Device::Page_Format format=A4, enum Fl_Paged_Device::Page_Layout layout=PORTRAIT) -> int\n"
		"Fl_PostScript_File_Device_begin_job(Fl_PostScript_File_Device self, FILE * ps_output, int pagecount=0, enum Fl_Paged_Device::Page_Format format=A4, enum Fl_Paged_Device::Page_Layout layout=PORTRAIT) -> int\n"
		""},
	 { "Fl_PostScript_File_Device_start_job", _wrap_Fl_PostScript_File_Device_start_job, METH_VARARGS, "\n"
		"Fl_PostScript_File_Device_start_job(Fl_PostScript_File_Device self, int pagecount=0, enum Fl_Paged_Device::Page_Format format=A4, enum Fl_Paged_Device::Page_Layout layout=PORTRAIT) -> int\n"
		"Fl_PostScript_File_Device_start_job(Fl_PostScript_File_Device self, FILE * ps_output, int pagecount=0, enum Fl_Paged_Device::Page_Format format=A4, enum Fl_Paged_Device::Page_Layout layout=PORTRAIT) -> int\n"
		""},
	 { "Fl_PostScript_File_Device_begin_page", _wrap_Fl_PostScript_File_Device_begin_page, METH_O, "Fl_PostScript_File_Device_begin_page(Fl_PostScript_File_Device self) -> int"},
	 { "Fl_PostScript_File_Device_printable_rect", _wrap_Fl_PostScript_File_Device_printable_rect, METH_O, "Fl_PostScript_File_Device_printable_rect(Fl_PostScript_File_Device self) -> int"},
	 { "Fl_PostScript_File_Device_margins", _wrap_Fl_PostScript_File_Device_margins, METH_O, "Fl_PostScript_File_Device_margins(Fl_PostScript_File_Device self)"},
	 { "Fl_PostScript_File_Device_origin", _wrap_Fl_PostScript_File_Device_origin, METH_VARARGS, "\n"
		"Fl_PostScript_File_Device_origin(Fl_PostScript_File_Device self)\n"
		"Fl_PostScript_File_Device_origin(Fl_PostScript_File_Device self, int x, int y)\n"
		""},
	 { "Fl_PostScript_File_Device_scale", _wrap_Fl_PostScript_File_Device_scale, METH_VARARGS, "Fl_PostScript_File_Device_scale(Fl_PostScript_File_Device self, float scale_x, float scale_y=0.)"},
	 { "Fl_PostScript_File_Device_rotate", _wrap_Fl_PostScript_File_Device_rotate, METH_VARARGS, "Fl_PostScript_File_Device_rotate(Fl_PostScript_File_Device self, float angle)"},
	 { "Fl_PostScript_File_Device_translate", _wrap_Fl_PostScript_File_Device_translate, METH_VARARGS, "Fl_PostScript_File_Device_translate(Fl_PostScript_File_Device self, int x, int y)"},
	 { "Fl_PostScript_File_Device_untranslate", _wrap_Fl_PostScript_File_Device_untranslate, METH_O, "Fl_PostScript_File_Device_untranslate(Fl_PostScript_File_Device self)"},
	 { "Fl_PostScript_File_Device_end_page", _wrap_Fl_PostScript_File_Device_end_page, METH_O, "Fl_PostScript_File_Device_end_page(Fl_PostScript_File_Device self) -> int"},
	 { "Fl_PostScript_File_Device_end_job", _wrap_Fl_PostScript_File_Device_end_job, METH_O, "Fl_PostScript_File_Device_end_job(Fl_PostScript_File_Device self)"},
	 { "Fl_PostScript_File_Device_file", _wrap_Fl_PostScript_File_Device_file, METH_O, "Fl_PostScript_File_Device_file(Fl_PostScript_File_Device self) -> FILE *"},
	 { "Fl_PostScript_File_Device_close_command", _wrap_Fl_PostScript_File_Device_close_command, METH_VARARGS, "Fl_PostScript_File_Device_close_command(Fl_PostScript_File_Device self, Fl_PostScript_Close_Command cmd)"},
	 { "Fl_PostScript_File_Device_set_current", _wrap_Fl_PostScript_File_Device_set_current, METH_O, "Fl_PostScript_File_Device_set_current(Fl_PostScript_File_Device self)"},
	 { "Fl_PostScript_File_Device_end_current", _wrap_Fl_PostScript_File_Device_end_current, METH_O, "Fl_PostScript_File_Device_end_current(Fl_PostScript_File_Device self)"},
	 { "disown_Fl_PostScript_File_Device", _wrap_disown_Fl_PostScript_File_Device, METH_O, NULL},
	 { "Fl_PostScript_File_Device_swigregister", Fl_PostScript_File_Device_swigregister, METH_O, NULL},
	 { "Fl_PostScript_File_Device_swiginit", Fl_PostScript_File_Device_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_EPS_File_Surface", _wrap_new_Fl_EPS_File_Surface, METH_VARARGS, "new_Fl_EPS_File_Surface(int width, int height, FILE * eps_output, Fl_Color background=, Fl_PostScript_Close_Command closef=None) -> Fl_EPS_File_Surface"},
	 { "delete_Fl_EPS_File_Surface", _wrap_delete_Fl_EPS_File_Surface, METH_O, "delete_Fl_EPS_File_Surface(Fl_EPS_File_Surface self)"},
	 { "Fl_EPS_File_Surface_printable_rect", _wrap_Fl_EPS_File_Surface_printable_rect, METH_O, "Fl_EPS_File_Surface_printable_rect(Fl_EPS_File_Surface self) -> int"},
	 { "Fl_EPS_File_Surface_file", _wrap_Fl_EPS_File_Surface_file, METH_O, "Fl_EPS_File_Surface_file(Fl_EPS_File_Surface self) -> FILE *"},
	 { "Fl_EPS_File_Surface_origin", _wrap_Fl_EPS_File_Surface_origin, METH_VARARGS, "\n"
		"Fl_EPS_File_Surface_origin(Fl_EPS_File_Surface self, int x, int y)\n"
		"Fl_EPS_File_Surface_origin(Fl_EPS_File_Surface self, int * px, int * py)\n"
		""},
	 { "Fl_EPS_File_Surface_translate", _wrap_Fl_EPS_File_Surface_translate, METH_VARARGS, "Fl_EPS_File_Surface_translate(Fl_EPS_File_Surface self, int x, int y)"},
	 { "Fl_EPS_File_Surface_untranslate", _wrap_Fl_EPS_File_Surface_untranslate, METH_O, "Fl_EPS_File_Surface_untranslate(Fl_EPS_File_Surface self)"},
	 { "Fl_EPS_File_Surface_close", _wrap_Fl_EPS_File_Surface_close, METH_O, "Fl_EPS_File_Surface_close(Fl_EPS_File_Surface self) -> int"},
	 { "Fl_EPS_File_Surface_swigregister", Fl_EPS_File_Surface_swigregister, METH_O, NULL},
	 { "Fl_EPS_File_Surface_swiginit", Fl_EPS_File_Surface_swiginit, METH_VARARGS, NULL},
	 { "new_Fl_Printer", _wrap_new_Fl_Printer, METH_O, "new_Fl_Printer(PyObject * _self) -> Fl_Printer"},
	 { "Fl_Printer_begin_job", _wrap_Fl_Printer_begin_job, METH_VARARGS, "Fl_Printer_begin_job(Fl_Printer self, int pagecount=0, int * frompage=None, int * topage=None, char ** perr_message=None) -> int"},
	 { "Fl_Printer_begin_page", _wrap_Fl_Printer_begin_page, METH_O, "Fl_Printer_begin_page(Fl_Printer self) -> int"},
	 { "Fl_Printer_printable_rect", _wrap_Fl_Printer_printable_rect, METH_O, "Fl_Printer_printable_rect(Fl_Printer self) -> int"},
	 { "Fl_Printer_margins", _wrap_Fl_Printer_margins, METH_O, "Fl_Printer_margins(Fl_Printer self)"},
	 { "Fl_Printer_origin", _wrap_Fl_Printer_origin, METH_VARARGS, "\n"
		"Fl_Printer_origin(Fl_Printer self)\n"
		"Fl_Printer_origin(Fl_Printer self, int x, int y)\n"
		""},
	 { "Fl_Printer_scale", _wrap_Fl_Printer_scale, METH_VARARGS, "Fl_Printer_scale(Fl_Printer self, float scale_x, float scale_y=0.)"},
	 { "Fl_Printer_rotate", _wrap_Fl_Printer_rotate, METH_VARARGS, "Fl_Printer_rotate(Fl_Printer self, float angle)"},
	 { "Fl_Printer_translate", _wrap_Fl_Printer_translate, METH_VARARGS, "Fl_Printer_translate(Fl_Printer self, int x, int y)"},
	 { "Fl_Printer_untranslate", _wrap_Fl_Printer_untranslate, METH_O, "Fl_Printer_untranslate(Fl_Printer self)"},
	 { "Fl_Printer_end_page", _wrap_Fl_Printer_end_page, METH_O, "Fl_Printer_end_page(Fl_Printer self) -> int"},
	 { "Fl_Printer_end_job", _wrap_Fl_Printer_end_job, METH_O, "Fl_Printer_end_job(Fl_Printer self)"},
	 { "Fl_Printer_set_current", _wrap_Fl_Printer_set_current, METH_O, "Fl_Printer_set_current(Fl_Printer self)"},
	 { "Fl_Printer_is_current", _wrap_Fl_Printer_is_current, METH_O, "Fl_Printer_is_current(Fl_Printer self) -> bool"},
	 { "delete_Fl_Printer", _wrap_delete_Fl_Printer, METH_O, "delete_Fl_Printer(Fl_Printer self)"},
	 { "disown_Fl_Printer", _wrap_disown_Fl_Printer, METH_O, NULL},
	 { "Fl_Printer_end_current", _wrap_Fl_Printer_end_current, METH_O, "Fl_Printer_end_current(Fl_Printer self)"},
	 { "Fl_Printer_swigregister", Fl_Printer_swigregister, METH_O, NULL},
	 { "Fl_Printer_swiginit", Fl_Printer_swiginit, METH_VARARGS, NULL},
	 { "fl_utf8bytes", _wrap_fl_utf8bytes, METH_O, "fl_utf8bytes(unsigned int ucs) -> int"},
	 { "fl_utf8len", _wrap_fl_utf8len, METH_O, "fl_utf8len(char c) -> int"},
	 { "fl_utf_nb_char", _wrap_fl_utf_nb_char, METH_VARARGS, "fl_utf_nb_char(unsigned char const * buf, int len) -> int"},
	 { "fl_utf8decode", _wrap_fl_utf8decode, METH_VARARGS, "fl_utf8decode(char const * p, char const * end, int * len) -> unsigned int"},
	 { "fl_utf8encode", _wrap_fl_utf8encode, METH_O, "fl_utf8encode(unsigned int ucs) -> int"},
	 { "fl_utf8fwd", _wrap_fl_utf8fwd, METH_VARARGS, "fl_utf8fwd(char const * p, char const * start, char const * end) -> char const *"},
	 { "fl_utf8back", _wrap_fl_utf8back, METH_VARARGS, "fl_utf8back(char const * p, char const * start, char const * end) -> char const *"},
	 { "fl_utf8toUtf16", _wrap_fl_utf8toUtf16, METH_VARARGS, "fl_utf8toUtf16(char const * src, unsigned int srclen, unsigned int dstlen) -> unsigned int"},
	 { "fl_utf8toa", _wrap_fl_utf8toa, METH_VARARGS, "fl_utf8toa(char const * src, unsigned int srclen, unsigned int arg3) -> unsigned int"},
	 { "fl_utf8froma", _wrap_fl_utf8froma, METH_VARARGS, "fl_utf8froma(char * dst, unsigned int dstlen, char const * src, unsigned int srclen) -> unsigned int"},
	 { "fl_utf8locale", _wrap_fl_utf8locale, METH_NOARGS, "fl_utf8locale() -> int"},
	 { "fl_utf8test", _wrap_fl_utf8test, METH_VARARGS, "fl_utf8test(char const * src, unsigned int len) -> int"},
	 { "fl_nonspacing", _wrap_fl_nonspacing, METH_O, "fl_nonspacing(unsigned int ucs) -> unsigned int"},
	 { "fl_utf8to_mb", _wrap_fl_utf8to_mb, METH_VARARGS, "fl_utf8to_mb(char const * src, unsigned int srclen, char * dst, unsigned int dstlen) -> unsigned int"},
	 { "fl_utf2mbcs", _wrap_fl_utf2mbcs, METH_O, "fl_utf2mbcs(char const * src) -> char *"},
	 { "fl_utf8from_mb", _wrap_fl_utf8from_mb, METH_VARARGS, "fl_utf8from_mb(char * dst, unsigned int dstlen, char const * src, unsigned int srclen) -> unsigned int"},
	 { "fl_utf8_to_locale", _wrap_fl_utf8_to_locale, METH_VARARGS, "fl_utf8_to_locale(char const * s, int len, unsigned int codepage) -> char *"},
	 { "fl_locale_to_utf8", _wrap_fl_locale_to_utf8, METH_VARARGS, "fl_locale_to_utf8(char const * s, int len, unsigned int codepage) -> char *"},
	 { "fl_utf_strncasecmp", _wrap_fl_utf_strncasecmp, METH_VARARGS, "fl_utf_strncasecmp(char const * s1, char const * s2, int n) -> int"},
	 { "fl_utf_strcasecmp", _wrap_fl_utf_strcasecmp, METH_VARARGS, "fl_utf_strcasecmp(char const * s1, char const * s2) -> int"},
	 { "fl_tolower", _wrap_fl_tolower, METH_O, "fl_tolower(unsigned int ucs) -> int"},
	 { "fl_toupper", _wrap_fl_toupper, METH_O, "fl_toupper(unsigned int ucs) -> int"},
	 { "fl_utf_tolower", _wrap_fl_utf_tolower, METH_VARARGS, "fl_utf_tolower(unsigned char const * str, int len) -> int"},
	 { "fl_utf_toupper", _wrap_fl_utf_toupper, METH_VARARGS, "fl_utf_toupper(unsigned char const * str, int len, char * buf) -> int"},
	 { "fl_chmod", _wrap_fl_chmod, METH_VARARGS, "fl_chmod(char const * f, int mode) -> int"},
	 { "fl_access", _wrap_fl_access, METH_VARARGS, "fl_access(char const * f, int mode) -> int"},
	 { "fl_getcwd", _wrap_fl_getcwd, METH_VARARGS, "fl_getcwd(char * buf, int maxlen) -> char *"},
	 { "fl_fopen", _wrap_fl_fopen, METH_VARARGS, "fl_fopen(char const * f, char const * mode) -> FILE *"},
	 { "fl_system", _wrap_fl_system, METH_O, "fl_system(char const * f) -> int"},
	 { "fl_execvp", _wrap_fl_execvp, METH_VARARGS, "fl_execvp(char const * file, char *const * argv) -> int"},
	 { "fl_open", _wrap_fl_open, METH_VARARGS, "fl_open(char const * f, int o) -> int"},
	 { "fl_unlink", _wrap_fl_unlink, METH_O, "fl_unlink(char const * f) -> int"},
	 { "fl_rmdir", _wrap_fl_rmdir, METH_O, "fl_rmdir(char const * f) -> int"},
	 { "fl_getenv", _wrap_fl_getenv, METH_O, "fl_getenv(char const * name) -> char *"},
	 { "fl_mkdir", _wrap_fl_mkdir, METH_VARARGS, "fl_mkdir(char const * f, int mode) -> int"},
	 { "fl_rename", _wrap_fl_rename, METH_VARARGS, "fl_rename(char const * f, char const * t) -> int"},
	 { "fl_make_path_for_file", _wrap_fl_make_path_for_file, METH_O, "fl_make_path_for_file(char const * path)"},
	 { "fl_make_path", _wrap_fl_make_path, METH_O, "fl_make_path(char const * path) -> char"},
	 { "upCB", _wrap_upCB, METH_VARARGS, "upCB(Fl_Widget v, void * arg2)"},
	 { "downCB", _wrap_downCB, METH_VARARGS, "downCB(Fl_Widget v, void * arg2)"},
	 { "toggleCB", _wrap_toggleCB, METH_VARARGS, "toggleCB(Fl_Widget v, void * arg2)"},
	 { "new_ListSelect", _wrap_new_ListSelect, METH_VARARGS, "new_ListSelect(PyObject * _self, int x, int y, int w, int h, char * topLabel=None, char * bottomLabel=None) -> ListSelect"},
	 { "ListSelect_getTopBrowser", _wrap_ListSelect_getTopBrowser, METH_O, "ListSelect_getTopBrowser(ListSelect self) -> Fl_Multi_Browser"},
	 { "ListSelect_getBottomBrowser", _wrap_ListSelect_getBottomBrowser, METH_O, "ListSelect_getBottomBrowser(ListSelect self) -> Fl_Multi_Browser"},
	 { "ListSelect_resize", _wrap_ListSelect_resize, METH_VARARGS, "ListSelect_resize(ListSelect self, int x, int y, int w, int h)"},
	 { "ListSelect_init_type", _wrap_ListSelect_init_type, METH_VARARGS, "ListSelect_init_type(ListSelect self, char * ListSelect)"},
	 { "delete_ListSelect", _wrap_delete_ListSelect, METH_O, "delete_ListSelect(ListSelect self)"},
	 { "disown_ListSelect", _wrap_disown_ListSelect, METH_O, NULL},
	 { "ListSelect_draw", _wrap_ListSelect_draw, METH_O, "ListSelect_draw(ListSelect self)"},
	 { "ListSelect_swigregister", ListSelect_swigregister, METH_O, NULL},
	 { "ListSelect_swiginit", ListSelect_swiginit, METH_VARARGS, NULL},
	 { "glLoadIdentity", _wrap_glLoadIdentity, METH_NOARGS, "glLoadIdentity()"},
	 { "glViewport", _wrap_glViewport, METH_VARARGS, "glViewport(int x, int y, int width, int height)"},
	 { "glClear", _wrap_glClear, METH_O, "glClear(int mask)"},
	 { "glColor3f", _wrap_glColor3f, METH_VARARGS, "glColor3f(float red, float green, float blue)"},
	 { "glBegin", _wrap_glBegin, METH_O, "glBegin(int mode)"},
	 { "glEnd", _wrap_glEnd, METH_NOARGS, "glEnd()"},
	 { "glVertex3f", _wrap_glVertex3f, METH_VARARGS, "glVertex3f(float x, float y, float z)"},
	 { "setMenu", setMenu, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};


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

static void *_p_p_Fl_BMP_ImageTo_p_p_Fl_RGB_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_RGB_Image **)  ((Fl_BMP_Image **) x));
}
static void *_p_p_Fl_ICO_ImageTo_p_p_Fl_RGB_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_RGB_Image **) (Fl_BMP_Image *) ((Fl_ICO_Image **) x));
}
static void *_p_p_Fl_JPEG_ImageTo_p_p_Fl_RGB_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_RGB_Image **)  ((Fl_JPEG_Image **) x));
}
static void *_p_p_Fl_PNG_ImageTo_p_p_Fl_RGB_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_RGB_Image **)  ((Fl_PNG_Image **) x));
}
static void *_p_p_Fl_PNM_ImageTo_p_p_Fl_RGB_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_RGB_Image **)  ((Fl_PNM_Image **) x));
}
static void *_p_p_Fl_SVG_ImageTo_p_p_Fl_RGB_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_RGB_Image **)  ((Fl_SVG_Image **) x));
}
static void *_p_Fl_ICO_ImageTo_p_Fl_BMP_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_BMP_Image *)  ((Fl_ICO_Image *) x));
}
static void *_p_Fl_XBM_ImageTo_p_Fl_Bitmap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Bitmap *)  ((Fl_XBM_Image *) x));
}
static void *_p_Fl_File_BrowserTo_p_Fl_Browser(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Browser *)  ((Fl_File_Browser *) x));
}
static void *_p_Fl_Hold_BrowserTo_p_Fl_Browser(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Browser *)  ((Fl_Hold_Browser *) x));
}
static void *_p_Fl_Multi_BrowserTo_p_Fl_Browser(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Browser *)  ((Fl_Multi_Browser *) x));
}
static void *_p_Fl_Select_BrowserTo_p_Fl_Browser(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Browser *)  ((Fl_Select_Browser *) x));
}
static void *_p_Fl_BrowserTo_p_Fl_Browser_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Browser_ *)  ((Fl_Browser *) x));
}
static void *_p_Fl_Check_BrowserTo_p_Fl_Browser_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Browser_ *)  ((Fl_Check_Browser *) x));
}
static void *_p_Fl_File_BrowserTo_p_Fl_Browser_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Browser_ *) (Fl_Browser *) ((Fl_File_Browser *) x));
}
static void *_p_Fl_Hold_BrowserTo_p_Fl_Browser_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Browser_ *) (Fl_Browser *) ((Fl_Hold_Browser *) x));
}
static void *_p_Fl_Multi_BrowserTo_p_Fl_Browser_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Browser_ *) (Fl_Browser *) ((Fl_Multi_Browser *) x));
}
static void *_p_Fl_Select_BrowserTo_p_Fl_Browser_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Browser_ *) (Fl_Browser *) ((Fl_Select_Browser *) x));
}
static void *_p_Fl_Check_ButtonTo_p_Fl_Button(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Button *) (Fl_Light_Button *) ((Fl_Check_Button *) x));
}
static void *_p_Fl_Light_ButtonTo_p_Fl_Button(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Button *)  ((Fl_Light_Button *) x));
}
static void *_p_Fl_Radio_ButtonTo_p_Fl_Button(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Button *)  ((Fl_Radio_Button *) x));
}
static void *_p_Fl_Radio_Light_ButtonTo_p_Fl_Button(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Button *) (Fl_Light_Button *) ((Fl_Radio_Light_Button *) x));
}
static void *_p_Fl_Radio_Round_ButtonTo_p_Fl_Button(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Button *) (Fl_Light_Button *)(Fl_Round_Button *) ((Fl_Radio_Round_Button *) x));
}
static void *_p_Fl_Repeat_ButtonTo_p_Fl_Button(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Button *)  ((Fl_Repeat_Button *) x));
}
static void *_p_Fl_Return_ButtonTo_p_Fl_Button(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Button *)  ((Fl_Return_Button *) x));
}
static void *_p_Fl_Round_ButtonTo_p_Fl_Button(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Button *) (Fl_Light_Button *) ((Fl_Round_Button *) x));
}
static void *_p_Fl_Shortcut_ButtonTo_p_Fl_Button(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Button *)  ((Fl_Shortcut_Button *) x));
}
static void *_p_Fl_Toggle_ButtonTo_p_Fl_Button(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Button *)  ((Fl_Toggle_Button *) x));
}
static void *_p_Fl_Scheme_ChoiceTo_p_Fl_Choice(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Choice *)  ((Fl_Scheme_Choice *) x));
}
static void *_p_Fl_Round_ClockTo_p_Fl_Clock(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Clock *)  ((Fl_Round_Clock *) x));
}
static void *_p_Fl_ClockTo_p_Fl_Clock_Output(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Clock_Output *)  ((Fl_Clock *) x));
}
static void *_p_Fl_Round_ClockTo_p_Fl_Clock_Output(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Clock_Output *) (Fl_Clock *) ((Fl_Round_Clock *) x));
}
static void *_p_Fl_Simple_CounterTo_p_Fl_Counter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Counter *)  ((Fl_Simple_Counter *) x));
}
static void *_p_Fl_Fill_DialTo_p_Fl_Dial(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Dial *)  ((Fl_Fill_Dial *) x));
}
static void *_p_Fl_Line_DialTo_p_Fl_Dial(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Dial *)  ((Fl_Line_Dial *) x));
}
static void *_p_Fl_Overlay_WindowTo_p_Fl_Double_Window(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Double_Window *)  ((Fl_Overlay_Window *) x));
}
static void *_p_Fl_Anim_GIF_ImageTo_p_Fl_GIF_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_GIF_Image *)  ((Fl_Anim_GIF_Image *) x));
}
static void *_p_Fl_BrowserTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *) (Fl_Browser_ *) ((Fl_Browser *) x));
}
static void *_p_Fl_Browser_To_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Browser_ *) x));
}
static void *_p_Fl_Check_BrowserTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *) (Fl_Browser_ *) ((Fl_Check_Browser *) x));
}
static void *_p_Fl_Color_ChooserTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Color_Chooser *) x));
}
static void *_p_Fl_Double_WindowTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *) (Fl_Window *) ((Fl_Double_Window *) x));
}
static void *_p_Fl_File_BrowserTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *) (Fl_Browser_ *)(Fl_Browser *) ((Fl_File_Browser *) x));
}
static void *_p_Fl_FlexTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Flex *) x));
}
static void *_p_Fl_Gl_WindowTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *) (Fl_Window *) ((Fl_Gl_Window *) x));
}
static void *_p_Fl_GridTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Grid *) x));
}
static void *_p_Fl_Help_ViewTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Help_View *) x));
}
static void *_p_Fl_Hold_BrowserTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *) (Fl_Browser_ *)(Fl_Browser *) ((Fl_Hold_Browser *) x));
}
static void *_p_Fl_Input_ChoiceTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Input_Choice *) x));
}
static void *_p_Fl_Menu_WindowTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *) (Fl_Window *)(Fl_Single_Window *) ((Fl_Menu_Window *) x));
}
static void *_p_Fl_Multi_BrowserTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *) (Fl_Browser_ *)(Fl_Browser *) ((Fl_Multi_Browser *) x));
}
static void *_p_Fl_Overlay_WindowTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *) (Fl_Window *)(Fl_Double_Window *) ((Fl_Overlay_Window *) x));
}
static void *_p_Fl_PackTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Pack *) x));
}
static void *_p_Fl_ScrollTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Scroll *) x));
}
static void *_p_Fl_Select_BrowserTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *) (Fl_Browser_ *)(Fl_Browser *) ((Fl_Select_Browser *) x));
}
static void *_p_Fl_Single_WindowTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *) (Fl_Window *) ((Fl_Single_Window *) x));
}
static void *_p_Fl_SpinnerTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Spinner *) x));
}
static void *_p_Fl_TableTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Table *) x));
}
static void *_p_Fl_Table_RowTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *) (Fl_Table *) ((Fl_Table_Row *) x));
}
static void *_p_Fl_TabsTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Tabs *) x));
}
static void *_p_Fl_TerminalTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Terminal *) x));
}
static void *_p_Fl_Text_DisplayTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Text_Display *) x));
}
static void *_p_Fl_Text_EditorTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *) (Fl_Text_Display *) ((Fl_Text_Editor *) x));
}
static void *_p_Fl_TileTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Tile *) x));
}
static void *_p_Fl_TreeTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Tree *) x));
}
static void *_p_Fl_WindowTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Window *) x));
}
static void *_p_Fl_WizardTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Wizard *) x));
}
static void *_p_ListSelectTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((ListSelect *) x));
}
static void *_p_Fl_Anim_GIF_ImageTo_p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *) (Fl_Pixmap *)(Fl_GIF_Image *) ((Fl_Anim_GIF_Image *) x));
}
static void *_p_Fl_BMP_ImageTo_p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *) (Fl_RGB_Image *) ((Fl_BMP_Image *) x));
}
static void *_p_Fl_BitmapTo_p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *)  ((Fl_Bitmap *) x));
}
static void *_p_Fl_GIF_ImageTo_p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *) (Fl_Pixmap *) ((Fl_GIF_Image *) x));
}
static void *_p_Fl_ICO_ImageTo_p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *) (Fl_RGB_Image *)(Fl_BMP_Image *) ((Fl_ICO_Image *) x));
}
static void *_p_Fl_JPEG_ImageTo_p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *) (Fl_RGB_Image *) ((Fl_JPEG_Image *) x));
}
static void *_p_Fl_PNG_ImageTo_p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *) (Fl_RGB_Image *) ((Fl_PNG_Image *) x));
}
static void *_p_Fl_PNM_ImageTo_p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *) (Fl_RGB_Image *) ((Fl_PNM_Image *) x));
}
static void *_p_Fl_PixmapTo_p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *)  ((Fl_Pixmap *) x));
}
static void *_p_Fl_RGB_ImageTo_p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *)  ((Fl_RGB_Image *) x));
}
static void *_p_Fl_SVG_ImageTo_p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *) (Fl_RGB_Image *) ((Fl_SVG_Image *) x));
}
static void *_p_Fl_Shared_ImageTo_p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *)  ((Fl_Shared_Image *) x));
}
static void *_p_Fl_Tiled_ImageTo_p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *)  ((Fl_Tiled_Image *) x));
}
static void *_p_Fl_XBM_ImageTo_p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *) (Fl_Bitmap *) ((Fl_XBM_Image *) x));
}
static void *_p_Fl_XPM_ImageTo_p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *) (Fl_Pixmap *) ((Fl_XPM_Image *) x));
}
static void *_p_Fl_File_InputTo_p_Fl_Input(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input *)  ((Fl_File_Input *) x));
}
static void *_p_Fl_Float_InputTo_p_Fl_Input(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input *)  ((Fl_Float_Input *) x));
}
static void *_p_Fl_Int_InputTo_p_Fl_Input(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input *)  ((Fl_Int_Input *) x));
}
static void *_p_Fl_Multiline_InputTo_p_Fl_Input(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input *)  ((Fl_Multiline_Input *) x));
}
static void *_p_Fl_Multiline_OutputTo_p_Fl_Input(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input *) (Fl_Output *) ((Fl_Multiline_Output *) x));
}
static void *_p_Fl_OutputTo_p_Fl_Input(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input *)  ((Fl_Output *) x));
}
static void *_p_Fl_Secret_InputTo_p_Fl_Input(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input *)  ((Fl_Secret_Input *) x));
}
static void *_p_Fl_File_InputTo_p_Fl_Input_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input_ *) (Fl_Input *) ((Fl_File_Input *) x));
}
static void *_p_Fl_Float_InputTo_p_Fl_Input_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input_ *) (Fl_Input *) ((Fl_Float_Input *) x));
}
static void *_p_Fl_InputTo_p_Fl_Input_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input_ *)  ((Fl_Input *) x));
}
static void *_p_Fl_Int_InputTo_p_Fl_Input_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input_ *) (Fl_Input *) ((Fl_Int_Input *) x));
}
static void *_p_Fl_Multiline_InputTo_p_Fl_Input_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input_ *) (Fl_Input *) ((Fl_Multiline_Input *) x));
}
static void *_p_Fl_Multiline_OutputTo_p_Fl_Input_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input_ *) (Fl_Input *)(Fl_Output *) ((Fl_Multiline_Output *) x));
}
static void *_p_Fl_OutputTo_p_Fl_Input_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input_ *) (Fl_Input *) ((Fl_Output *) x));
}
static void *_p_Fl_Secret_InputTo_p_Fl_Input_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input_ *) (Fl_Input *) ((Fl_Secret_Input *) x));
}
static void *_p_Fl_Check_ButtonTo_p_Fl_Light_Button(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Light_Button *)  ((Fl_Check_Button *) x));
}
static void *_p_Fl_Radio_Light_ButtonTo_p_Fl_Light_Button(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Light_Button *)  ((Fl_Radio_Light_Button *) x));
}
static void *_p_Fl_Radio_Round_ButtonTo_p_Fl_Light_Button(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Light_Button *) (Fl_Round_Button *) ((Fl_Radio_Round_Button *) x));
}
static void *_p_Fl_Round_ButtonTo_p_Fl_Light_Button(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Light_Button *)  ((Fl_Round_Button *) x));
}
static void *_p_Fl_ChoiceTo_p_Fl_Menu_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Menu_ *)  ((Fl_Choice *) x));
}
static void *_p_Fl_Menu_BarTo_p_Fl_Menu_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Menu_ *)  ((Fl_Menu_Bar *) x));
}
static void *_p_Fl_Menu_ButtonTo_p_Fl_Menu_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Menu_ *)  ((Fl_Menu_Button *) x));
}
static void *_p_Fl_Scheme_ChoiceTo_p_Fl_Menu_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Menu_ *) (Fl_Choice *) ((Fl_Scheme_Choice *) x));
}
static void *_p_Fl_Sys_Menu_BarTo_p_Fl_Menu_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Menu_ *) (Fl_Menu_Bar *) ((Fl_Sys_Menu_Bar *) x));
}
static void *_p_Fl_Sys_Menu_BarTo_p_Fl_Menu_Bar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Menu_Bar *)  ((Fl_Sys_Menu_Bar *) x));
}
static void *_p_Fl_Native_File_Chooser_FLTK_DriverTo_p_Fl_Native_File_Chooser_Driver(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Native_File_Chooser_Driver *)  ((Fl_Native_File_Chooser_FLTK_Driver *) x));
}
static void *_p_Fl_Multiline_OutputTo_p_Fl_Output(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Output *)  ((Fl_Multiline_Output *) x));
}
static void *_p_Fl_PDF_File_SurfaceTo_p_Fl_Paged_Device(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Paged_Device *)  ((Fl_PDF_File_Surface *) x));
}
static void *_p_Fl_PostScript_File_DeviceTo_p_Fl_Paged_Device(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Paged_Device *)  ((Fl_PostScript_File_Device *) x));
}
static void *_p_Fl_PrinterTo_p_Fl_Paged_Device(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Paged_Device *)  ((Fl_Printer *) x));
}
static void *_p_Fl_Anim_GIF_ImageTo_p_Fl_Pixmap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Pixmap *) (Fl_GIF_Image *) ((Fl_Anim_GIF_Image *) x));
}
static void *_p_Fl_GIF_ImageTo_p_Fl_Pixmap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Pixmap *)  ((Fl_GIF_Image *) x));
}
static void *_p_Fl_XPM_ImageTo_p_Fl_Pixmap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Pixmap *)  ((Fl_XPM_Image *) x));
}
static void *_p_Fl_Device_PluginTo_p_Fl_Plugin(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Plugin *)  ((Fl_Device_Plugin *) x));
}
static void *_p_Fl_BMP_ImageTo_p_Fl_RGB_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_RGB_Image *)  ((Fl_BMP_Image *) x));
}
static void *_p_Fl_ICO_ImageTo_p_Fl_RGB_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_RGB_Image *) (Fl_BMP_Image *) ((Fl_ICO_Image *) x));
}
static void *_p_Fl_JPEG_ImageTo_p_Fl_RGB_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_RGB_Image *)  ((Fl_JPEG_Image *) x));
}
static void *_p_Fl_PNG_ImageTo_p_Fl_RGB_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_RGB_Image *)  ((Fl_PNG_Image *) x));
}
static void *_p_Fl_PNM_ImageTo_p_Fl_RGB_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_RGB_Image *)  ((Fl_PNM_Image *) x));
}
static void *_p_Fl_SVG_ImageTo_p_Fl_RGB_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_RGB_Image *)  ((Fl_SVG_Image *) x));
}
static void *_p_Fl_Radio_Round_ButtonTo_p_Fl_Round_Button(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Round_Button *)  ((Fl_Radio_Round_Button *) x));
}
static void *_p_Fl_Menu_WindowTo_p_Fl_Single_Window(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Single_Window *)  ((Fl_Menu_Window *) x));
}
static void *_p_Fl_Fill_SliderTo_p_Fl_Slider(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Slider *)  ((Fl_Fill_Slider *) x));
}
static void *_p_Fl_Hor_Fill_SliderTo_p_Fl_Slider(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Slider *)  ((Fl_Hor_Fill_Slider *) x));
}
static void *_p_Fl_Hor_Nice_SliderTo_p_Fl_Slider(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Slider *)  ((Fl_Hor_Nice_Slider *) x));
}
static void *_p_Fl_Hor_SliderTo_p_Fl_Slider(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Slider *)  ((Fl_Hor_Slider *) x));
}
static void *_p_Fl_Hor_Value_SliderTo_p_Fl_Slider(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Slider *) (Fl_Value_Slider *) ((Fl_Hor_Value_Slider *) x));
}
static void *_p_Fl_Nice_SliderTo_p_Fl_Slider(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Slider *)  ((Fl_Nice_Slider *) x));
}
static void *_p_Fl_ScrollbarTo_p_Fl_Slider(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Slider *)  ((Fl_Scrollbar *) x));
}
static void *_p_Fl_Value_SliderTo_p_Fl_Slider(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Slider *)  ((Fl_Value_Slider *) x));
}
static void *_p_Fl_Display_DeviceTo_p_Fl_Surface_Device(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Surface_Device *)  ((Fl_Display_Device *) x));
}
static void *_p_Fl_EPS_File_SurfaceTo_p_Fl_Surface_Device(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Surface_Device *) (Fl_Widget_Surface *) ((Fl_EPS_File_Surface *) x));
}
static void *_p_Fl_Image_SurfaceTo_p_Fl_Surface_Device(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Surface_Device *) (Fl_Widget_Surface *) ((Fl_Image_Surface *) x));
}
static void *_p_Fl_Image_Surface_DriverTo_p_Fl_Surface_Device(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Surface_Device *) (Fl_Widget_Surface *) ((Fl_Image_Surface_Driver *) x));
}
static void *_p_Fl_PDF_File_SurfaceTo_p_Fl_Surface_Device(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Surface_Device *) (Fl_Widget_Surface *)(Fl_Paged_Device *) ((Fl_PDF_File_Surface *) x));
}
static void *_p_Fl_Paged_DeviceTo_p_Fl_Surface_Device(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Surface_Device *) (Fl_Widget_Surface *) ((Fl_Paged_Device *) x));
}
static void *_p_Fl_PostScript_File_DeviceTo_p_Fl_Surface_Device(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Surface_Device *) (Fl_Widget_Surface *)(Fl_Paged_Device *) ((Fl_PostScript_File_Device *) x));
}
static void *_p_Fl_PrinterTo_p_Fl_Surface_Device(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Surface_Device *) (Fl_Widget_Surface *)(Fl_Paged_Device *) ((Fl_Printer *) x));
}
static void *_p_Fl_SVG_File_SurfaceTo_p_Fl_Surface_Device(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Surface_Device *) (Fl_Widget_Surface *) ((Fl_SVG_File_Surface *) x));
}
static void *_p_Fl_Table_RowTo_p_Fl_Table(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Table *)  ((Fl_Table_Row *) x));
}
static void *_p_Fl_Text_EditorTo_p_Fl_Text_Display(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Text_Display *)  ((Fl_Text_Editor *) x));
}
static void *_p_Fl_AdjusterTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *)  ((Fl_Adjuster *) x));
}
static void *_p_Fl_CounterTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *)  ((Fl_Counter *) x));
}
static void *_p_Fl_DialTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *)  ((Fl_Dial *) x));
}
static void *_p_Fl_Fill_DialTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *) (Fl_Dial *) ((Fl_Fill_Dial *) x));
}
static void *_p_Fl_Fill_SliderTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *) (Fl_Slider *) ((Fl_Fill_Slider *) x));
}
static void *_p_Fl_Hor_Fill_SliderTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *) (Fl_Slider *) ((Fl_Hor_Fill_Slider *) x));
}
static void *_p_Fl_Hor_Nice_SliderTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *) (Fl_Slider *) ((Fl_Hor_Nice_Slider *) x));
}
static void *_p_Fl_Hor_SliderTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *) (Fl_Slider *) ((Fl_Hor_Slider *) x));
}
static void *_p_Fl_Hor_Value_SliderTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *) (Fl_Slider *)(Fl_Value_Slider *) ((Fl_Hor_Value_Slider *) x));
}
static void *_p_Fl_Line_DialTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *) (Fl_Dial *) ((Fl_Line_Dial *) x));
}
static void *_p_Fl_Nice_SliderTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *) (Fl_Slider *) ((Fl_Nice_Slider *) x));
}
static void *_p_Fl_RollerTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *)  ((Fl_Roller *) x));
}
static void *_p_Fl_ScrollbarTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *) (Fl_Slider *) ((Fl_Scrollbar *) x));
}
static void *_p_Fl_Simple_CounterTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *) (Fl_Counter *) ((Fl_Simple_Counter *) x));
}
static void *_p_Fl_SliderTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *)  ((Fl_Slider *) x));
}
static void *_p_Fl_Value_InputTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *)  ((Fl_Value_Input *) x));
}
static void *_p_Fl_Value_OutputTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *)  ((Fl_Value_Output *) x));
}
static void *_p_Fl_Value_SliderTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *) (Fl_Slider *) ((Fl_Value_Slider *) x));
}
static void *_p_Flcc_Value_InputTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *) (Fl_Value_Input *) ((Flcc_Value_Input *) x));
}
static void *_p_Flcc_Value_InputTo_p_Fl_Value_Input(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Value_Input *)  ((Flcc_Value_Input *) x));
}
static void *_p_Fl_Hor_Value_SliderTo_p_Fl_Value_Slider(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Value_Slider *)  ((Fl_Hor_Value_Slider *) x));
}
static void *_p_Fl_AdjusterTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *) ((Fl_Adjuster *) x));
}
static void *_p_Fl_BoxTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Fl_Box *) x));
}
static void *_p_Fl_BrowserTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *)(Fl_Browser_ *) ((Fl_Browser *) x));
}
static void *_p_Fl_Browser_To_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Browser_ *) x));
}
static void *_p_Fl_ButtonTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Fl_Button *) x));
}
static void *_p_Fl_ChartTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Fl_Chart *) x));
}
static void *_p_Fl_Check_BrowserTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *)(Fl_Browser_ *) ((Fl_Check_Browser *) x));
}
static void *_p_Fl_Check_ButtonTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Button *)(Fl_Light_Button *) ((Fl_Check_Button *) x));
}
static void *_p_Fl_ChoiceTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Menu_ *) ((Fl_Choice *) x));
}
static void *_p_Fl_ClockTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Clock_Output *) ((Fl_Clock *) x));
}
static void *_p_Fl_Clock_OutputTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Fl_Clock_Output *) x));
}
static void *_p_Fl_Color_ChooserTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Color_Chooser *) x));
}
static void *_p_Fl_CounterTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *) ((Fl_Counter *) x));
}
static void *_p_Fl_DialTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *) ((Fl_Dial *) x));
}
static void *_p_Fl_Double_WindowTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *)(Fl_Window *) ((Fl_Double_Window *) x));
}
static void *_p_Fl_File_BrowserTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *)(Fl_Browser_ *)(Fl_Browser *) ((Fl_File_Browser *) x));
}
static void *_p_Fl_File_InputTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Input_ *)(Fl_Input *) ((Fl_File_Input *) x));
}
static void *_p_Fl_Fill_DialTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *)(Fl_Dial *) ((Fl_Fill_Dial *) x));
}
static void *_p_Fl_Fill_SliderTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *)(Fl_Slider *) ((Fl_Fill_Slider *) x));
}
static void *_p_Fl_FlexTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Flex *) x));
}
static void *_p_Fl_Float_InputTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Input_ *)(Fl_Input *) ((Fl_Float_Input *) x));
}
static void *_p_Fl_Gl_WindowTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *)(Fl_Window *) ((Fl_Gl_Window *) x));
}
static void *_p_Fl_GridTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Grid *) x));
}
static void *_p_Fl_GroupTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Fl_Group *) x));
}
static void *_p_Fl_Help_ViewTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Help_View *) x));
}
static void *_p_Fl_Hold_BrowserTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *)(Fl_Browser_ *)(Fl_Browser *) ((Fl_Hold_Browser *) x));
}
static void *_p_Fl_Hor_Fill_SliderTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *)(Fl_Slider *) ((Fl_Hor_Fill_Slider *) x));
}
static void *_p_Fl_Hor_Nice_SliderTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *)(Fl_Slider *) ((Fl_Hor_Nice_Slider *) x));
}
static void *_p_Fl_Hor_SliderTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *)(Fl_Slider *) ((Fl_Hor_Slider *) x));
}
static void *_p_Fl_Hor_Value_SliderTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *)(Fl_Slider *)(Fl_Value_Slider *) ((Fl_Hor_Value_Slider *) x));
}
static void *_p_Fl_InputTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Input_ *) ((Fl_Input *) x));
}
static void *_p_Fl_Input_To_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Fl_Input_ *) x));
}
static void *_p_Fl_Input_ChoiceTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Input_Choice *) x));
}
static void *_p_Fl_Int_InputTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Input_ *)(Fl_Input *) ((Fl_Int_Input *) x));
}
static void *_p_Fl_Light_ButtonTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Button *) ((Fl_Light_Button *) x));
}
static void *_p_Fl_Line_DialTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *)(Fl_Dial *) ((Fl_Line_Dial *) x));
}
static void *_p_Fl_Menu_To_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Fl_Menu_ *) x));
}
static void *_p_Fl_Menu_BarTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Menu_ *) ((Fl_Menu_Bar *) x));
}
static void *_p_Fl_Menu_ButtonTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Menu_ *) ((Fl_Menu_Button *) x));
}
static void *_p_Fl_Menu_WindowTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *)(Fl_Window *)(Fl_Single_Window *) ((Fl_Menu_Window *) x));
}
static void *_p_Fl_Multi_BrowserTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *)(Fl_Browser_ *)(Fl_Browser *) ((Fl_Multi_Browser *) x));
}
static void *_p_Fl_Multiline_InputTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Input_ *)(Fl_Input *) ((Fl_Multiline_Input *) x));
}
static void *_p_Fl_Multiline_OutputTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Input_ *)(Fl_Input *)(Fl_Output *) ((Fl_Multiline_Output *) x));
}
static void *_p_Fl_Nice_SliderTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *)(Fl_Slider *) ((Fl_Nice_Slider *) x));
}
static void *_p_Fl_OutputTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Input_ *)(Fl_Input *) ((Fl_Output *) x));
}
static void *_p_Fl_Overlay_WindowTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *)(Fl_Window *)(Fl_Double_Window *) ((Fl_Overlay_Window *) x));
}
static void *_p_Fl_PackTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Pack *) x));
}
static void *_p_Fl_PositionerTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Fl_Positioner *) x));
}
static void *_p_Fl_ProgressTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Fl_Progress *) x));
}
static void *_p_Fl_Radio_ButtonTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Button *) ((Fl_Radio_Button *) x));
}
static void *_p_Fl_Radio_Light_ButtonTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Button *)(Fl_Light_Button *) ((Fl_Radio_Light_Button *) x));
}
static void *_p_Fl_Radio_Round_ButtonTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Button *)(Fl_Light_Button *)(Fl_Round_Button *) ((Fl_Radio_Round_Button *) x));
}
static void *_p_Fl_Repeat_ButtonTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Button *) ((Fl_Repeat_Button *) x));
}
static void *_p_Fl_Return_ButtonTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Button *) ((Fl_Return_Button *) x));
}
static void *_p_Fl_RollerTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *) ((Fl_Roller *) x));
}
static void *_p_Fl_Round_ButtonTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Button *)(Fl_Light_Button *) ((Fl_Round_Button *) x));
}
static void *_p_Fl_Round_ClockTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Clock_Output *)(Fl_Clock *) ((Fl_Round_Clock *) x));
}
static void *_p_Fl_Scheme_ChoiceTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Menu_ *)(Fl_Choice *) ((Fl_Scheme_Choice *) x));
}
static void *_p_Fl_ScrollTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Scroll *) x));
}
static void *_p_Fl_ScrollbarTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *)(Fl_Slider *) ((Fl_Scrollbar *) x));
}
static void *_p_Fl_Secret_InputTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Input_ *)(Fl_Input *) ((Fl_Secret_Input *) x));
}
static void *_p_Fl_Select_BrowserTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *)(Fl_Browser_ *)(Fl_Browser *) ((Fl_Select_Browser *) x));
}
static void *_p_Fl_Shortcut_ButtonTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Button *) ((Fl_Shortcut_Button *) x));
}
static void *_p_Fl_Simple_CounterTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *)(Fl_Counter *) ((Fl_Simple_Counter *) x));
}
static void *_p_Fl_Single_WindowTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *)(Fl_Window *) ((Fl_Single_Window *) x));
}
static void *_p_Fl_SliderTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *) ((Fl_Slider *) x));
}
static void *_p_Fl_SpinnerTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Spinner *) x));
}
static void *_p_Fl_Sys_Menu_BarTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Menu_ *)(Fl_Menu_Bar *) ((Fl_Sys_Menu_Bar *) x));
}
static void *_p_Fl_TableTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Table *) x));
}
static void *_p_Fl_Table_RowTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *)(Fl_Table *) ((Fl_Table_Row *) x));
}
static void *_p_Fl_TabsTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Tabs *) x));
}
static void *_p_Fl_TerminalTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Terminal *) x));
}
static void *_p_Fl_Text_DisplayTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Text_Display *) x));
}
static void *_p_Fl_Text_EditorTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *)(Fl_Text_Display *) ((Fl_Text_Editor *) x));
}
static void *_p_Fl_TileTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Tile *) x));
}
static void *_p_Fl_Toggle_ButtonTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Button *) ((Fl_Toggle_Button *) x));
}
static void *_p_Fl_TreeTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Tree *) x));
}
static void *_p_Fl_ValuatorTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Fl_Valuator *) x));
}
static void *_p_Fl_Value_InputTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *) ((Fl_Value_Input *) x));
}
static void *_p_Fl_Value_OutputTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *) ((Fl_Value_Output *) x));
}
static void *_p_Fl_Value_SliderTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *)(Fl_Slider *) ((Fl_Value_Slider *) x));
}
static void *_p_Fl_WindowTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Window *) x));
}
static void *_p_Fl_WizardTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Wizard *) x));
}
static void *_p_Flcc_HueBoxTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Flcc_HueBox *) x));
}
static void *_p_Flcc_ValueBoxTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Flcc_ValueBox *) x));
}
static void *_p_Flcc_Value_InputTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *)(Fl_Value_Input *) ((Flcc_Value_Input *) x));
}
static void *_p_ListSelectTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((ListSelect *) x));
}
static void *_p_Fl_Copy_SurfaceTo_p_Fl_Widget_Surface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget_Surface *)  ((Fl_Copy_Surface *) x));
}
static void *_p_Fl_Copy_Surface_DriverTo_p_Fl_Widget_Surface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget_Surface *)  ((Fl_Copy_Surface_Driver *) x));
}
static void *_p_Fl_EPS_File_SurfaceTo_p_Fl_Widget_Surface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget_Surface *)  ((Fl_EPS_File_Surface *) x));
}
static void *_p_Fl_Image_SurfaceTo_p_Fl_Widget_Surface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget_Surface *)  ((Fl_Image_Surface *) x));
}
static void *_p_Fl_Image_Surface_DriverTo_p_Fl_Widget_Surface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget_Surface *)  ((Fl_Image_Surface_Driver *) x));
}
static void *_p_Fl_PDF_File_SurfaceTo_p_Fl_Widget_Surface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget_Surface *) (Fl_Paged_Device *) ((Fl_PDF_File_Surface *) x));
}
static void *_p_Fl_Paged_DeviceTo_p_Fl_Widget_Surface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget_Surface *)  ((Fl_Paged_Device *) x));
}
static void *_p_Fl_PostScript_File_DeviceTo_p_Fl_Widget_Surface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget_Surface *) (Fl_Paged_Device *) ((Fl_PostScript_File_Device *) x));
}
static void *_p_Fl_PrinterTo_p_Fl_Widget_Surface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget_Surface *) (Fl_Paged_Device *) ((Fl_Printer *) x));
}
static void *_p_Fl_SVG_File_SurfaceTo_p_Fl_Widget_Surface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget_Surface *)  ((Fl_SVG_File_Surface *) x));
}
static void *_p_Fl_Double_WindowTo_p_Fl_Window(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Window *)  ((Fl_Double_Window *) x));
}
static void *_p_Fl_Gl_WindowTo_p_Fl_Window(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Window *)  ((Fl_Gl_Window *) x));
}
static void *_p_Fl_Menu_WindowTo_p_Fl_Window(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Window *) (Fl_Single_Window *) ((Fl_Menu_Window *) x));
}
static void *_p_Fl_Overlay_WindowTo_p_Fl_Window(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Window *) (Fl_Double_Window *) ((Fl_Overlay_Window *) x));
}
static void *_p_Fl_Single_WindowTo_p_Fl_Window(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Window *)  ((Fl_Single_Window *) x));
}
static void *_p_f_p_q_const__char_p_uchar_int__p_Fl_Anim_GIF_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *(*)(char const *,uchar *,int)) (Fl_Pixmap *)(Fl_GIF_Image *) ((Fl_Anim_GIF_Image *(*)(char const *,uchar *,int)) x));
}
static void *_p_f_p_q_const__char_p_uchar_int__p_Fl_BMP_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *(*)(char const *,uchar *,int)) (Fl_RGB_Image *) ((Fl_BMP_Image *(*)(char const *,uchar *,int)) x));
}
static void *_p_f_p_q_const__char_p_uchar_int__p_Fl_BitmapTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *(*)(char const *,uchar *,int))  ((Fl_Bitmap *(*)(char const *,uchar *,int)) x));
}
static void *_p_f_p_q_const__char_p_uchar_int__p_Fl_GIF_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *(*)(char const *,uchar *,int)) (Fl_Pixmap *) ((Fl_GIF_Image *(*)(char const *,uchar *,int)) x));
}
static void *_p_f_p_q_const__char_p_uchar_int__p_Fl_ICO_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *(*)(char const *,uchar *,int)) (Fl_RGB_Image *)(Fl_BMP_Image *) ((Fl_ICO_Image *(*)(char const *,uchar *,int)) x));
}
static void *_p_f_p_q_const__char_p_uchar_int__p_Fl_JPEG_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *(*)(char const *,uchar *,int)) (Fl_RGB_Image *) ((Fl_JPEG_Image *(*)(char const *,uchar *,int)) x));
}
static void *_p_f_p_q_const__char_p_uchar_int__p_Fl_PNG_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *(*)(char const *,uchar *,int)) (Fl_RGB_Image *) ((Fl_PNG_Image *(*)(char const *,uchar *,int)) x));
}
static void *_p_f_p_q_const__char_p_uchar_int__p_Fl_PNM_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *(*)(char const *,uchar *,int)) (Fl_RGB_Image *) ((Fl_PNM_Image *(*)(char const *,uchar *,int)) x));
}
static void *_p_f_p_q_const__char_p_uchar_int__p_Fl_PixmapTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *(*)(char const *,uchar *,int))  ((Fl_Pixmap *(*)(char const *,uchar *,int)) x));
}
static void *_p_f_p_q_const__char_p_uchar_int__p_Fl_RGB_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *(*)(char const *,uchar *,int))  ((Fl_RGB_Image *(*)(char const *,uchar *,int)) x));
}
static void *_p_f_p_q_const__char_p_uchar_int__p_Fl_SVG_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *(*)(char const *,uchar *,int)) (Fl_RGB_Image *) ((Fl_SVG_Image *(*)(char const *,uchar *,int)) x));
}
static void *_p_f_p_q_const__char_p_uchar_int__p_Fl_Shared_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *(*)(char const *,uchar *,int))  ((Fl_Shared_Image *(*)(char const *,uchar *,int)) x));
}
static void *_p_f_p_q_const__char_p_uchar_int__p_Fl_Tiled_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *(*)(char const *,uchar *,int))  ((Fl_Tiled_Image *(*)(char const *,uchar *,int)) x));
}
static void *_p_f_p_q_const__char_p_uchar_int__p_Fl_XBM_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *(*)(char const *,uchar *,int)) (Fl_Bitmap *) ((Fl_XBM_Image *(*)(char const *,uchar *,int)) x));
}
static void *_p_f_p_q_const__char_p_uchar_int__p_Fl_XPM_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *(*)(char const *,uchar *,int)) (Fl_Pixmap *) ((Fl_XPM_Image *(*)(char const *,uchar *,int)) x));
}
static void *_p_p_Fl_AdjusterTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *) ((Fl_Adjuster **) x));
}
static void *_p_p_Fl_BoxTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_Box **) x));
}
static void *_p_p_Fl_BrowserTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *)(Fl_Browser_ *) ((Fl_Browser **) x));
}
static void *_p_p_Fl_Browser_To_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Browser_ **) x));
}
static void *_p_p_Fl_ButtonTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_Button **) x));
}
static void *_p_p_Fl_ChartTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_Chart **) x));
}
static void *_p_p_Fl_Check_BrowserTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *)(Fl_Browser_ *) ((Fl_Check_Browser **) x));
}
static void *_p_p_Fl_Check_ButtonTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Button *)(Fl_Light_Button *) ((Fl_Check_Button **) x));
}
static void *_p_p_Fl_ChoiceTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Menu_ *) ((Fl_Choice **) x));
}
static void *_p_p_Fl_ClockTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Clock_Output *) ((Fl_Clock **) x));
}
static void *_p_p_Fl_Clock_OutputTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_Clock_Output **) x));
}
static void *_p_p_Fl_Color_ChooserTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Color_Chooser **) x));
}
static void *_p_p_Fl_CounterTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *) ((Fl_Counter **) x));
}
static void *_p_p_Fl_DialTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *) ((Fl_Dial **) x));
}
static void *_p_p_Fl_Double_WindowTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *)(Fl_Window *) ((Fl_Double_Window **) x));
}
static void *_p_p_Fl_File_BrowserTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *)(Fl_Browser_ *)(Fl_Browser *) ((Fl_File_Browser **) x));
}
static void *_p_p_Fl_File_InputTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Input_ *)(Fl_Input *) ((Fl_File_Input **) x));
}
static void *_p_p_Fl_Fill_DialTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *)(Fl_Dial *) ((Fl_Fill_Dial **) x));
}
static void *_p_p_Fl_Fill_SliderTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *)(Fl_Slider *) ((Fl_Fill_Slider **) x));
}
static void *_p_p_Fl_FlexTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Flex **) x));
}
static void *_p_p_Fl_Float_InputTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Input_ *)(Fl_Input *) ((Fl_Float_Input **) x));
}
static void *_p_p_Fl_Gl_WindowTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *)(Fl_Window *) ((Fl_Gl_Window **) x));
}
static void *_p_p_Fl_GridTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Grid **) x));
}
static void *_p_p_Fl_GroupTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_Group **) x));
}
static void *_p_p_Fl_Help_ViewTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Help_View **) x));
}
static void *_p_p_Fl_Hold_BrowserTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *)(Fl_Browser_ *)(Fl_Browser *) ((Fl_Hold_Browser **) x));
}
static void *_p_p_Fl_Hor_Fill_SliderTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *)(Fl_Slider *) ((Fl_Hor_Fill_Slider **) x));
}
static void *_p_p_Fl_Hor_Nice_SliderTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *)(Fl_Slider *) ((Fl_Hor_Nice_Slider **) x));
}
static void *_p_p_Fl_Hor_SliderTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *)(Fl_Slider *) ((Fl_Hor_Slider **) x));
}
static void *_p_p_Fl_Hor_Value_SliderTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *)(Fl_Slider *)(Fl_Value_Slider *) ((Fl_Hor_Value_Slider **) x));
}
static void *_p_p_Fl_InputTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Input_ *) ((Fl_Input **) x));
}
static void *_p_p_Fl_Input_To_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_Input_ **) x));
}
static void *_p_p_Fl_Input_ChoiceTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Input_Choice **) x));
}
static void *_p_p_Fl_Int_InputTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Input_ *)(Fl_Input *) ((Fl_Int_Input **) x));
}
static void *_p_p_Fl_Light_ButtonTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Button *) ((Fl_Light_Button **) x));
}
static void *_p_p_Fl_Line_DialTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *)(Fl_Dial *) ((Fl_Line_Dial **) x));
}
static void *_p_p_Fl_Menu_To_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_Menu_ **) x));
}
static void *_p_p_Fl_Menu_BarTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Menu_ *) ((Fl_Menu_Bar **) x));
}
static void *_p_p_Fl_Menu_ButtonTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Menu_ *) ((Fl_Menu_Button **) x));
}
static void *_p_p_Fl_Menu_WindowTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *)(Fl_Window *)(Fl_Single_Window *) ((Fl_Menu_Window **) x));
}
static void *_p_p_Fl_Multi_BrowserTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *)(Fl_Browser_ *)(Fl_Browser *) ((Fl_Multi_Browser **) x));
}
static void *_p_p_Fl_Multiline_InputTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Input_ *)(Fl_Input *) ((Fl_Multiline_Input **) x));
}
static void *_p_p_Fl_Multiline_OutputTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Input_ *)(Fl_Input *)(Fl_Output *) ((Fl_Multiline_Output **) x));
}
static void *_p_p_Fl_Nice_SliderTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *)(Fl_Slider *) ((Fl_Nice_Slider **) x));
}
static void *_p_p_Fl_OutputTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Input_ *)(Fl_Input *) ((Fl_Output **) x));
}
static void *_p_p_Fl_Overlay_WindowTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *)(Fl_Window *)(Fl_Double_Window *) ((Fl_Overlay_Window **) x));
}
static void *_p_p_Fl_PackTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Pack **) x));
}
static void *_p_p_Fl_PositionerTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_Positioner **) x));
}
static void *_p_p_Fl_ProgressTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_Progress **) x));
}
static void *_p_p_Fl_Radio_ButtonTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Button *) ((Fl_Radio_Button **) x));
}
static void *_p_p_Fl_Radio_Light_ButtonTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Button *)(Fl_Light_Button *) ((Fl_Radio_Light_Button **) x));
}
static void *_p_p_Fl_Radio_Round_ButtonTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Button *)(Fl_Light_Button *)(Fl_Round_Button *) ((Fl_Radio_Round_Button **) x));
}
static void *_p_p_Fl_Repeat_ButtonTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Button *) ((Fl_Repeat_Button **) x));
}
static void *_p_p_Fl_Return_ButtonTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Button *) ((Fl_Return_Button **) x));
}
static void *_p_p_Fl_RollerTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *) ((Fl_Roller **) x));
}
static void *_p_p_Fl_Round_ButtonTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Button *)(Fl_Light_Button *) ((Fl_Round_Button **) x));
}
static void *_p_p_Fl_Round_ClockTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Clock_Output *)(Fl_Clock *) ((Fl_Round_Clock **) x));
}
static void *_p_p_Fl_Scheme_ChoiceTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Menu_ *)(Fl_Choice *) ((Fl_Scheme_Choice **) x));
}
static void *_p_p_Fl_ScrollTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Scroll **) x));
}
static void *_p_p_Fl_ScrollbarTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *)(Fl_Slider *) ((Fl_Scrollbar **) x));
}
static void *_p_p_Fl_Secret_InputTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Input_ *)(Fl_Input *) ((Fl_Secret_Input **) x));
}
static void *_p_p_Fl_Select_BrowserTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *)(Fl_Browser_ *)(Fl_Browser *) ((Fl_Select_Browser **) x));
}
static void *_p_p_Fl_Shortcut_ButtonTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Button *) ((Fl_Shortcut_Button **) x));
}
static void *_p_p_Fl_Simple_CounterTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *)(Fl_Counter *) ((Fl_Simple_Counter **) x));
}
static void *_p_p_Fl_Single_WindowTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *)(Fl_Window *) ((Fl_Single_Window **) x));
}
static void *_p_p_Fl_SliderTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *) ((Fl_Slider **) x));
}
static void *_p_p_Fl_SpinnerTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Spinner **) x));
}
static void *_p_p_Fl_Sys_Menu_BarTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Menu_ *)(Fl_Menu_Bar *) ((Fl_Sys_Menu_Bar **) x));
}
static void *_p_p_Fl_TableTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Table **) x));
}
static void *_p_p_Fl_Table_RowTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *)(Fl_Table *) ((Fl_Table_Row **) x));
}
static void *_p_p_Fl_TabsTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Tabs **) x));
}
static void *_p_p_Fl_TerminalTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Terminal **) x));
}
static void *_p_p_Fl_Text_DisplayTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Text_Display **) x));
}
static void *_p_p_Fl_Text_EditorTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *)(Fl_Text_Display *) ((Fl_Text_Editor **) x));
}
static void *_p_p_Fl_TileTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Tile **) x));
}
static void *_p_p_Fl_Toggle_ButtonTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Button *) ((Fl_Toggle_Button **) x));
}
static void *_p_p_Fl_TreeTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Tree **) x));
}
static void *_p_p_Fl_ValuatorTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_Valuator **) x));
}
static void *_p_p_Fl_Value_InputTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *) ((Fl_Value_Input **) x));
}
static void *_p_p_Fl_Value_OutputTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *) ((Fl_Value_Output **) x));
}
static void *_p_p_Fl_Value_SliderTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *)(Fl_Slider *) ((Fl_Value_Slider **) x));
}
static void *_p_p_Fl_WindowTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Window **) x));
}
static void *_p_p_Fl_WizardTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Wizard **) x));
}
static void *_p_p_Flcc_HueBoxTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Flcc_HueBox **) x));
}
static void *_p_p_Flcc_ValueBoxTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Flcc_ValueBox **) x));
}
static void *_p_p_Flcc_Value_InputTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *)(Fl_Value_Input *) ((Flcc_Value_Input **) x));
}
static void *_p_p_ListSelectTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((ListSelect **) x));
}
static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FL_CHART_ENTRY = {"_p_FL_CHART_ENTRY", "FL_CHART_ENTRY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Abort_Handler = {"_p_Fl_Abort_Handler", "Fl_Abort_Handler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Adjuster = {"_p_Fl_Adjuster", "Fl_Adjuster *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Anim_GIF_Image = {"_p_Fl_Anim_GIF_Image", "Fl_Anim_GIF_Image *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Args_Handler = {"_p_Fl_Args_Handler", "Fl_Args_Handler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Atclose_Handler = {"_p_Fl_Atclose_Handler", "Fl_Atclose_Handler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Awake_Handler = {"_p_Fl_Awake_Handler", "Fl_Awake_Handler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_BMP_Image = {"_p_Fl_BMP_Image", "Fl_BMP_Image *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Bitmap = {"_p_Fl_Bitmap", "Fl_Bitmap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Box = {"_p_Fl_Box", "Fl_Box *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Box_Draw_F = {"_p_Fl_Box_Draw_F", "Fl_Box_Draw_F *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Box_Draw_Focus_F = {"_p_Fl_Box_Draw_Focus_F", "Fl_Box_Draw_Focus_F *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Browser = {"_p_Fl_Browser", "Fl_Browser *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Browser_ = {"_p_Fl_Browser_", "Fl_Browser_ *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Button = {"_p_Fl_Button", "Fl_Button *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Callback_User_Data = {"_p_Fl_Callback_User_Data", "Fl_Callback_User_Data *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Chart = {"_p_Fl_Chart", "Fl_Chart *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Check_Browser = {"_p_Fl_Check_Browser", "Fl_Check_Browser *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Check_Button = {"_p_Fl_Check_Button", "Fl_Check_Button *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Choice = {"_p_Fl_Choice", "Fl_Choice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Clipboard_Notify_Handler = {"_p_Fl_Clipboard_Notify_Handler", "Fl_Clipboard_Notify_Handler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Clock = {"_p_Fl_Clock", "Fl_Clock *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Clock_Output = {"_p_Fl_Clock_Output", "Fl_Clock_Output *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Color_Chooser = {"_p_Fl_Color_Chooser", "Fl_Color_Chooser *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Copy_Surface = {"_p_Fl_Copy_Surface", "Fl_Copy_Surface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Copy_Surface_Driver = {"_p_Fl_Copy_Surface_Driver", "Fl_Copy_Surface_Driver *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Counter = {"_p_Fl_Counter", "Fl_Counter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Device_Plugin = {"_p_Fl_Device_Plugin", "Fl_Device_Plugin *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Dial = {"_p_Fl_Dial", "Fl_Dial *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Display_Device = {"_p_Fl_Display_Device", "Fl_Display_Device *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Double_Window = {"_p_Fl_Double_Window", "Fl_Double_Window *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_EPS_File_Surface = {"_p_Fl_EPS_File_Surface", "Fl_EPS_File_Surface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_End = {"_p_Fl_End", "Fl_End *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_File_Browser = {"_p_Fl_File_Browser", "Fl_File_Browser *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_File_Chooser = {"_p_Fl_File_Chooser", "Fl_File_Chooser *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_File_Icon = {"_p_Fl_File_Icon", "Fl_File_Icon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_File_Input = {"_p_Fl_File_Input", "Fl_File_Input *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Fill_Dial = {"_p_Fl_Fill_Dial", "Fl_Fill_Dial *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Fill_Slider = {"_p_Fl_Fill_Slider", "Fl_Fill_Slider *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Flex = {"_p_Fl_Flex", "Fl_Flex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Float_Input = {"_p_Fl_Float_Input", "Fl_Float_Input *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_GIF_Image = {"_p_Fl_GIF_Image", "Fl_GIF_Image *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Gl_Window = {"_p_Fl_Gl_Window", "Fl_Gl_Window *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Graphics_Driver = {"_p_Fl_Graphics_Driver", "Fl_Graphics_Driver *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Grid = {"_p_Fl_Grid", "Fl_Grid *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Grid__Cell = {"_p_Fl_Grid__Cell", "Fl_Grid::Cell *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Group = {"_p_Fl_Group", "Fl_Group *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Help_Dialog = {"_p_Fl_Help_Dialog", "Fl_Help_Dialog *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Help_View = {"_p_Fl_Help_View", "Fl_Help_View *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Hold_Browser = {"_p_Fl_Hold_Browser", "Fl_Hold_Browser *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Hor_Fill_Slider = {"_p_Fl_Hor_Fill_Slider", "Fl_Hor_Fill_Slider *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Hor_Nice_Slider = {"_p_Fl_Hor_Nice_Slider", "Fl_Hor_Nice_Slider *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Hor_Slider = {"_p_Fl_Hor_Slider", "Fl_Hor_Slider *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Hor_Value_Slider = {"_p_Fl_Hor_Value_Slider", "Fl_Hor_Value_Slider *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_ICO_Image = {"_p_Fl_ICO_Image", "Fl_ICO_Image *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_ICO_Image__IconDirEntry = {"_p_Fl_ICO_Image__IconDirEntry", "Fl_ICO_Image::IconDirEntry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Idle_Handler = {"_p_Fl_Idle_Handler", "Fl_Idle_Handler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Image = {"_p_Fl_Image", "Fl_Image *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Image_Surface = {"_p_Fl_Image_Surface", "Fl_Image_Surface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Input = {"_p_Fl_Input", "Fl_Input *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Input_ = {"_p_Fl_Input_", "Fl_Input_ *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Input_Choice = {"_p_Fl_Input_Choice", "Fl_Input_Choice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Int_Input = {"_p_Fl_Int_Input", "Fl_Int_Input *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_JPEG_Image = {"_p_Fl_JPEG_Image", "Fl_JPEG_Image *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Label = {"_p_Fl_Label", "Fl_Label *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Label_Draw_F = {"_p_Fl_Label_Draw_F", "Fl_Label_Draw_F *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Label_Measure_F = {"_p_Fl_Label_Measure_F", "Fl_Label_Measure_F *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Light_Button = {"_p_Fl_Light_Button", "Fl_Light_Button *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Line_Dial = {"_p_Fl_Line_Dial", "Fl_Line_Dial *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Menu_ = {"_p_Fl_Menu_", "Fl_Menu_ *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Menu_Bar = {"_p_Fl_Menu_Bar", "Fl_Menu_Bar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Menu_Button = {"_p_Fl_Menu_Button", "Fl_Menu_Button *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Menu_Item = {"_p_Fl_Menu_Item", "Fl_Menu *|Fl_Menu_Item *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Menu_Window = {"_p_Fl_Menu_Window", "Fl_Menu_Window *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Multi_Browser = {"_p_Fl_Multi_Browser", "Fl_Multi_Browser *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Multi_Label = {"_p_Fl_Multi_Label", "Fl_Multi_Label *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Multiline_Input = {"_p_Fl_Multiline_Input", "Fl_Multiline_Input *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Multiline_Output = {"_p_Fl_Multiline_Output", "Fl_Multiline_Output *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Native_File_Chooser = {"_p_Fl_Native_File_Chooser", "Fl_Native_File_Chooser *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Native_File_Chooser_Driver = {"_p_Fl_Native_File_Chooser_Driver", "Fl_Native_File_Chooser_Driver *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Native_File_Chooser_FLTK_Driver = {"_p_Fl_Native_File_Chooser_FLTK_Driver", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_Fl_Nice_Slider = {"_p_Fl_Nice_Slider", "Fl_Nice_Slider *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Offscreen = {"_p_Fl_Offscreen", "Fl_Offscreen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Old_Idle_Handler = {"_p_Fl_Old_Idle_Handler", "Fl_Old_Idle_Handler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Output = {"_p_Fl_Output", "Fl_Output *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Overlay_Window = {"_p_Fl_Overlay_Window", "Fl_Overlay_Window *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_PDF_File_Surface = {"_p_Fl_PDF_File_Surface", "Fl_PDF_File_Surface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_PNG_Image = {"_p_Fl_PNG_Image", "Fl_PNG_Image *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_PNM_Image = {"_p_Fl_PNM_Image", "Fl_PNM_Image *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Pack = {"_p_Fl_Pack", "Fl_Pack *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Paged_Device = {"_p_Fl_Paged_Device", "Fl_Paged_Device *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Pixmap = {"_p_Fl_Pixmap", "Fl_Pixmap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Plugin = {"_p_Fl_Plugin", "Fl_Plugin *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Plugin_Manager = {"_p_Fl_Plugin_Manager", "Fl_Plugin_Manager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Positioner = {"_p_Fl_Positioner", "Fl_Positioner *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_PostScript_File_Device = {"_p_Fl_PostScript_File_Device", "Fl_PostScript_File_Device *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Preferences = {"_p_Fl_Preferences", "Fl_Preferences *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Preferences__ID = {"_p_Fl_Preferences__ID", "Fl_Preferences::ID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Printer = {"_p_Fl_Printer", "Fl_Printer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Progress = {"_p_Fl_Progress", "Fl_Progress *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_RGB_Image = {"_p_Fl_RGB_Image", "Fl_RGB_Image *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Radio_Button = {"_p_Fl_Radio_Button", "Fl_Radio_Button *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Radio_Light_Button = {"_p_Fl_Radio_Light_Button", "Fl_Radio_Light_Button *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Radio_Round_Button = {"_p_Fl_Radio_Round_Button", "Fl_Radio_Round_Button *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Rect = {"_p_Fl_Rect", "Fl_Rect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Region = {"_p_Fl_Region", "Fl_Region *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Repeat_Button = {"_p_Fl_Repeat_Button", "Fl_Repeat_Button *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Return_Button = {"_p_Fl_Return_Button", "Fl_Return_Button *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Roller = {"_p_Fl_Roller", "Fl_Roller *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Round_Button = {"_p_Fl_Round_Button", "Fl_Round_Button *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Round_Clock = {"_p_Fl_Round_Clock", "Fl_Round_Clock *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_SVG_File_Surface = {"_p_Fl_SVG_File_Surface", "Fl_SVG_File_Surface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_SVG_Image = {"_p_Fl_SVG_Image", "Fl_SVG_Image *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Scheme_Choice = {"_p_Fl_Scheme_Choice", "Fl_Scheme_Choice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Screen_Driver = {"_p_Fl_Screen_Driver", "Fl_Screen_Driver *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Scroll = {"_p_Fl_Scroll", "Fl_Scroll *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Scrollbar = {"_p_Fl_Scrollbar", "Fl_Scrollbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Secret_Input = {"_p_Fl_Secret_Input", "Fl_Secret_Input *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Select_Browser = {"_p_Fl_Select_Browser", "Fl_Select_Browser *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Shared_Image = {"_p_Fl_Shared_Image", "Fl_Shared_Image *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Shortcut_Button = {"_p_Fl_Shortcut_Button", "Fl_Shortcut_Button *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Simple_Counter = {"_p_Fl_Simple_Counter", "Fl_Simple_Counter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Single_Window = {"_p_Fl_Single_Window", "Fl_Single_Window *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Slider = {"_p_Fl_Slider", "Fl_Slider *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Spinner = {"_p_Fl_Spinner", "Fl_Spinner *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Surface_Device = {"_p_Fl_Surface_Device", "Fl_Surface_Device *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Image_Surface_Driver = {"_p_Fl_Image_Surface_Driver", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_Fl_Sys_Menu_Bar = {"_p_Fl_Sys_Menu_Bar", "Fl_Sys_Menu_Bar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_System_Driver = {"_p_Fl_System_Driver", "Fl_System_Driver *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Table = {"_p_Fl_Table", "Fl_Table *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Table_Row = {"_p_Fl_Table_Row", "Fl_Table_Row *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Tabs = {"_p_Fl_Tabs", "Fl_Tabs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Terminal = {"_p_Fl_Terminal", "Fl_Terminal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Text_Buffer = {"_p_Fl_Text_Buffer", "Fl_Text_Buffer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Text_Display = {"_p_Fl_Text_Display", "Fl_Text_Display *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Text_Display__Style_Table_Entry = {"_p_Fl_Text_Display__Style_Table_Entry", "Fl_Text_Display::Style_Table_Entry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Text_Editor = {"_p_Fl_Text_Editor", "Fl_Text_Editor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Text_Editor__Key_Binding = {"_p_Fl_Text_Editor__Key_Binding", "Fl_Text_Editor::Key_Binding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Text_Selection = {"_p_Fl_Text_Selection", "Fl_Text_Selection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Tile = {"_p_Fl_Tile", "Fl_Tile *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Tiled_Image = {"_p_Fl_Tiled_Image", "Fl_Tiled_Image *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Timeout_Handler = {"_p_Fl_Timeout_Handler", "Fl_Timeout_Handler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Timestamp = {"_p_Fl_Timestamp", "Fl_Timestamp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Toggle_Button = {"_p_Fl_Toggle_Button", "Fl_Toggle_Button *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Tooltip = {"_p_Fl_Tooltip", "Fl_Tooltip *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Tree = {"_p_Fl_Tree", "Fl_Tree *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Tree_Item = {"_p_Fl_Tree_Item", "Fl_Tree_Item *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Tree_Item_Array = {"_p_Fl_Tree_Item_Array", "Fl_Tree_Item_Array *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Tree_Prefs = {"_p_Fl_Tree_Prefs", "Fl_Tree_Prefs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Valuator = {"_p_Fl_Valuator", "Fl_Valuator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Value_Input = {"_p_Fl_Value_Input", "Fl_Value_Input *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Value_Output = {"_p_Fl_Value_Output", "Fl_Value_Output *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Value_Slider = {"_p_Fl_Value_Slider", "Fl_Value_Slider *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Vk_Window = {"_p_Fl_Vk_Window", "Fl_Vk_Window *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Widget = {"_p_Fl_Widget", "Fl_Widget *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Widget_Surface = {"_p_Fl_Widget_Surface", "Fl_Widget_Surface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Window = {"_p_Fl_Window", "Fl_Window *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Wizard = {"_p_Fl_Wizard", "Fl_Wizard *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_X = {"_p_Fl_X", "Fl_X *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_XBM_Image = {"_p_Fl_XBM_Image", "Fl_XBM_Image *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_XPM_Image = {"_p_Fl_XPM_Image", "Fl_XPM_Image *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl__TimeoutData = {"_p_Fl__TimeoutData", "Fl::TimeoutData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Flcc_HueBox = {"_p_Flcc_HueBox", "Flcc_HueBox *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Flcc_ValueBox = {"_p_Flcc_ValueBox", "Flcc_ValueBox *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Flcc_Value_Input = {"_p_Flcc_Value_Input", "Flcc_Value_Input *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GLContext = {"_p_GLContext", "GLContext *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListSelect = {"_p_ListSelect", "ListSelect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Scale_Type = {"_p_Scale_Type", "Scale_Type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Style_Table_Entry = {"_p_Style_Table_Entry", "Style_Table_Entry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Tick_Position = {"_p_Tick_Position", "Tick_Position *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Window = {"_p_Window", "Window *", 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_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_int_int_int_int_p_q_const__char_p_void__void = {"_p_f_int_int_int_int_p_q_const__char_p_void__void", "Fl_Text_Modify_Cb|void (*)(int,int,int,int,char const *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_int_int_p_void__void = {"_p_f_int_int_p_void__void", "Fl_Text_Predelete_Cb|void (*)(int,int,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_int_p_Fl_Text_Editor__int = {"_p_f_int_p_Fl_Text_Editor__int", "Fl_Text_Editor::Key_Func|int (*)(int,Fl_Text_Editor *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_FILE__int = {"_p_f_p_FILE__int", "Fl_PostScript_Close_Command|int (*)(FILE *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_Fl_File_Chooser_p_void__void = {"_p_f_p_Fl_File_Chooser_p_void__void", "void (*)(Fl_File_Chooser *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_Fl_Tree_Item_p_void__void = {"_p_f_p_Fl_Tree_Item_p_void__void", "Fl_Tree_Item_Draw_Callback *|void (*)(Fl_Tree_Item *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_Fl_Widget__void = {"_p_f_p_Fl_Widget__void", "Fl_Callback0 *|void (*)(Fl_Widget *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_Fl_Widget_long__void = {"_p_f_p_Fl_Widget_long__void", "Fl_Callback1 *|void (*)(Fl_Widget *,long)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_Fl_Widget_p_q_const__char__p_char = {"_p_f_p_Fl_Widget_p_q_const__char__p_char", "Fl_Help_Func *|char *(*)(Fl_Widget *,char const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_Fl_Widget_p_void__void = {"_p_f_p_Fl_Widget_p_void__void", "Fl_Callback *|Fl_Callback_p|void (*)(Fl_Widget *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__char__void = {"_p_f_p_q_const__char__void", "void (*)(char const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_int_int_int__void = {"_p_f_p_q_const__char_int_int_int__void", "void (*)(char const *,int,int,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Image = {"_p_f_p_q_const__char_p_uchar_int__p_Fl_Image", "Fl_Shared_Handler|Fl_Image *(*)(char const *,uchar *,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Anim_GIF_Image = {"_p_f_p_q_const__char_p_uchar_int__p_Fl_Anim_GIF_Image", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_BMP_Image = {"_p_f_p_q_const__char_p_uchar_int__p_Fl_BMP_Image", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Bitmap = {"_p_f_p_q_const__char_p_uchar_int__p_Fl_Bitmap", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_GIF_Image = {"_p_f_p_q_const__char_p_uchar_int__p_Fl_GIF_Image", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_ICO_Image = {"_p_f_p_q_const__char_p_uchar_int__p_Fl_ICO_Image", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_JPEG_Image = {"_p_f_p_q_const__char_p_uchar_int__p_Fl_JPEG_Image", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_PNG_Image = {"_p_f_p_q_const__char_p_uchar_int__p_Fl_PNG_Image", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_PNM_Image = {"_p_f_p_q_const__char_p_uchar_int__p_Fl_PNM_Image", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Pixmap = {"_p_f_p_q_const__char_p_uchar_int__p_Fl_Pixmap", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_RGB_Image = {"_p_f_p_q_const__char_p_uchar_int__p_Fl_RGB_Image", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_SVG_Image = {"_p_f_p_q_const__char_p_uchar_int__p_Fl_SVG_Image", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Shared_Image = {"_p_f_p_q_const__char_p_uchar_int__p_Fl_Shared_Image", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Tiled_Image = {"_p_f_p_q_const__char_p_uchar_int__p_Fl_Tiled_Image", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_XBM_Image = {"_p_f_p_q_const__char_p_uchar_int__p_Fl_XBM_Image", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_XPM_Image = {"_p_f_p_q_const__char_p_uchar_int__p_Fl_XPM_Image", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_p_void_int_int_int_int__void = {"_p_f_p_void_int_int_int_int__void", "void (*)(void *,int,int,int,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_unsigned_int__void = {"_p_f_unsigned_int__void", "void (*)(Fl_Color)|void (*)(unsigned int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_unsigned_int_unsigned_int_int_int__unsigned_int = {"_p_f_unsigned_int_unsigned_int_int_int__unsigned_int", "Fl_Contrast_Function *|unsigned int (*)(unsigned int,unsigned int,int,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_fl_uintptr_t = {"_p_fl_uintptr_t", "fl_uintptr_t *", 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_int = {"_p_int", "Fl_Font *|Fl_Fontsize *|int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_Fl_RGB_Image = {"_p_p_Fl_RGB_Image", "Fl_RGB_Image **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_Fl_BMP_Image = {"_p_p_Fl_BMP_Image", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_ICO_Image = {"_p_p_Fl_ICO_Image", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_JPEG_Image = {"_p_p_Fl_JPEG_Image", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_PNG_Image = {"_p_p_Fl_PNG_Image", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_PNM_Image = {"_p_p_Fl_PNM_Image", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_SVG_Image = {"_p_p_Fl_SVG_Image", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Shared_Image = {"_p_p_Fl_Shared_Image", "Fl_Shared_Image **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_Fl_Widget = {"_p_p_Fl_Widget", "Fl_Widget **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_Fl_Adjuster = {"_p_p_Fl_Adjuster", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Box = {"_p_p_Fl_Box", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Browser = {"_p_p_Fl_Browser", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Browser_ = {"_p_p_Fl_Browser_", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Button = {"_p_p_Fl_Button", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Chart = {"_p_p_Fl_Chart", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Check_Browser = {"_p_p_Fl_Check_Browser", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Check_Button = {"_p_p_Fl_Check_Button", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Choice = {"_p_p_Fl_Choice", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Clock = {"_p_p_Fl_Clock", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Clock_Output = {"_p_p_Fl_Clock_Output", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Color_Chooser = {"_p_p_Fl_Color_Chooser", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Counter = {"_p_p_Fl_Counter", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Dial = {"_p_p_Fl_Dial", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Double_Window = {"_p_p_Fl_Double_Window", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_File_Browser = {"_p_p_Fl_File_Browser", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_File_Input = {"_p_p_Fl_File_Input", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Fill_Dial = {"_p_p_Fl_Fill_Dial", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Fill_Slider = {"_p_p_Fl_Fill_Slider", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Flex = {"_p_p_Fl_Flex", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Float_Input = {"_p_p_Fl_Float_Input", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Gl_Window = {"_p_p_Fl_Gl_Window", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Grid = {"_p_p_Fl_Grid", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Group = {"_p_p_Fl_Group", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Help_View = {"_p_p_Fl_Help_View", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Hold_Browser = {"_p_p_Fl_Hold_Browser", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Hor_Fill_Slider = {"_p_p_Fl_Hor_Fill_Slider", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Hor_Nice_Slider = {"_p_p_Fl_Hor_Nice_Slider", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Hor_Slider = {"_p_p_Fl_Hor_Slider", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Hor_Value_Slider = {"_p_p_Fl_Hor_Value_Slider", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Input = {"_p_p_Fl_Input", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Input_ = {"_p_p_Fl_Input_", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Input_Choice = {"_p_p_Fl_Input_Choice", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Int_Input = {"_p_p_Fl_Int_Input", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Light_Button = {"_p_p_Fl_Light_Button", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Line_Dial = {"_p_p_Fl_Line_Dial", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Menu_ = {"_p_p_Fl_Menu_", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Menu_Bar = {"_p_p_Fl_Menu_Bar", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Menu_Button = {"_p_p_Fl_Menu_Button", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Menu_Window = {"_p_p_Fl_Menu_Window", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Multi_Browser = {"_p_p_Fl_Multi_Browser", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Multiline_Input = {"_p_p_Fl_Multiline_Input", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Multiline_Output = {"_p_p_Fl_Multiline_Output", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Nice_Slider = {"_p_p_Fl_Nice_Slider", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Output = {"_p_p_Fl_Output", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Overlay_Window = {"_p_p_Fl_Overlay_Window", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Pack = {"_p_p_Fl_Pack", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Positioner = {"_p_p_Fl_Positioner", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Progress = {"_p_p_Fl_Progress", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Radio_Button = {"_p_p_Fl_Radio_Button", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Radio_Light_Button = {"_p_p_Fl_Radio_Light_Button", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Radio_Round_Button = {"_p_p_Fl_Radio_Round_Button", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Repeat_Button = {"_p_p_Fl_Repeat_Button", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Return_Button = {"_p_p_Fl_Return_Button", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Roller = {"_p_p_Fl_Roller", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Round_Button = {"_p_p_Fl_Round_Button", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Round_Clock = {"_p_p_Fl_Round_Clock", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Scheme_Choice = {"_p_p_Fl_Scheme_Choice", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Scroll = {"_p_p_Fl_Scroll", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Scrollbar = {"_p_p_Fl_Scrollbar", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Secret_Input = {"_p_p_Fl_Secret_Input", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Select_Browser = {"_p_p_Fl_Select_Browser", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Shortcut_Button = {"_p_p_Fl_Shortcut_Button", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Simple_Counter = {"_p_p_Fl_Simple_Counter", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Single_Window = {"_p_p_Fl_Single_Window", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Slider = {"_p_p_Fl_Slider", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Spinner = {"_p_p_Fl_Spinner", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Sys_Menu_Bar = {"_p_p_Fl_Sys_Menu_Bar", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Table = {"_p_p_Fl_Table", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Table_Row = {"_p_p_Fl_Table_Row", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Tabs = {"_p_p_Fl_Tabs", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Terminal = {"_p_p_Fl_Terminal", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Text_Display = {"_p_p_Fl_Text_Display", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Text_Editor = {"_p_p_Fl_Text_Editor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Tile = {"_p_p_Fl_Tile", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Toggle_Button = {"_p_p_Fl_Toggle_Button", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Tree = {"_p_p_Fl_Tree", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Valuator = {"_p_p_Fl_Valuator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Value_Input = {"_p_p_Fl_Value_Input", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Value_Output = {"_p_p_Fl_Value_Output", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Value_Slider = {"_p_p_Fl_Value_Slider", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Window = {"_p_p_Fl_Window", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Wizard = {"_p_p_Fl_Wizard", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Flcc_HueBox = {"_p_p_Flcc_HueBox", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Flcc_ValueBox = {"_p_p_Flcc_ValueBox", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Flcc_Value_Input = {"_p_p_Flcc_Value_Input", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_ListSelect = {"_p_p_ListSelect", 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_p_char = {"_p_p_p_char", "char ***", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_p_dirent = {"_p_p_p_dirent", "dirent ***", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Fl__TimeoutData_t = {"_p_std__vectorT_Fl__TimeoutData_t", "std::vector< Fl::TimeoutData > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "uchar *|unsigned char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "Fl_Align *|Fl_Color *|Fl_Shortcut *|unsigned int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "ulong *|unsigned long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "Fl_Grid_Align *|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 _swigt__p_window_menu_style_enum = {"_p_window_menu_style_enum", "window_menu_style_enum *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_FILE,
  &_swigt__p_FL_CHART_ENTRY,
  &_swigt__p_Fl_Abort_Handler,
  &_swigt__p_Fl_Adjuster,
  &_swigt__p_Fl_Anim_GIF_Image,
  &_swigt__p_Fl_Args_Handler,
  &_swigt__p_Fl_Atclose_Handler,
  &_swigt__p_Fl_Awake_Handler,
  &_swigt__p_Fl_BMP_Image,
  &_swigt__p_Fl_Bitmap,
  &_swigt__p_Fl_Box,
  &_swigt__p_Fl_Box_Draw_F,
  &_swigt__p_Fl_Box_Draw_Focus_F,
  &_swigt__p_Fl_Browser,
  &_swigt__p_Fl_Browser_,
  &_swigt__p_Fl_Button,
  &_swigt__p_Fl_Callback_User_Data,
  &_swigt__p_Fl_Chart,
  &_swigt__p_Fl_Check_Browser,
  &_swigt__p_Fl_Check_Button,
  &_swigt__p_Fl_Choice,
  &_swigt__p_Fl_Clipboard_Notify_Handler,
  &_swigt__p_Fl_Clock,
  &_swigt__p_Fl_Clock_Output,
  &_swigt__p_Fl_Color_Chooser,
  &_swigt__p_Fl_Copy_Surface,
  &_swigt__p_Fl_Copy_Surface_Driver,
  &_swigt__p_Fl_Counter,
  &_swigt__p_Fl_Device_Plugin,
  &_swigt__p_Fl_Dial,
  &_swigt__p_Fl_Display_Device,
  &_swigt__p_Fl_Double_Window,
  &_swigt__p_Fl_EPS_File_Surface,
  &_swigt__p_Fl_End,
  &_swigt__p_Fl_File_Browser,
  &_swigt__p_Fl_File_Chooser,
  &_swigt__p_Fl_File_Icon,
  &_swigt__p_Fl_File_Input,
  &_swigt__p_Fl_Fill_Dial,
  &_swigt__p_Fl_Fill_Slider,
  &_swigt__p_Fl_Flex,
  &_swigt__p_Fl_Float_Input,
  &_swigt__p_Fl_GIF_Image,
  &_swigt__p_Fl_Gl_Window,
  &_swigt__p_Fl_Graphics_Driver,
  &_swigt__p_Fl_Grid,
  &_swigt__p_Fl_Grid__Cell,
  &_swigt__p_Fl_Group,
  &_swigt__p_Fl_Help_Dialog,
  &_swigt__p_Fl_Help_View,
  &_swigt__p_Fl_Hold_Browser,
  &_swigt__p_Fl_Hor_Fill_Slider,
  &_swigt__p_Fl_Hor_Nice_Slider,
  &_swigt__p_Fl_Hor_Slider,
  &_swigt__p_Fl_Hor_Value_Slider,
  &_swigt__p_Fl_ICO_Image,
  &_swigt__p_Fl_ICO_Image__IconDirEntry,
  &_swigt__p_Fl_Idle_Handler,
  &_swigt__p_Fl_Image,
  &_swigt__p_Fl_Image_Surface,
  &_swigt__p_Fl_Image_Surface_Driver,
  &_swigt__p_Fl_Input,
  &_swigt__p_Fl_Input_,
  &_swigt__p_Fl_Input_Choice,
  &_swigt__p_Fl_Int_Input,
  &_swigt__p_Fl_JPEG_Image,
  &_swigt__p_Fl_Label,
  &_swigt__p_Fl_Label_Draw_F,
  &_swigt__p_Fl_Label_Measure_F,
  &_swigt__p_Fl_Light_Button,
  &_swigt__p_Fl_Line_Dial,
  &_swigt__p_Fl_Menu_,
  &_swigt__p_Fl_Menu_Bar,
  &_swigt__p_Fl_Menu_Button,
  &_swigt__p_Fl_Menu_Item,
  &_swigt__p_Fl_Menu_Window,
  &_swigt__p_Fl_Multi_Browser,
  &_swigt__p_Fl_Multi_Label,
  &_swigt__p_Fl_Multiline_Input,
  &_swigt__p_Fl_Multiline_Output,
  &_swigt__p_Fl_Native_File_Chooser,
  &_swigt__p_Fl_Native_File_Chooser_Driver,
  &_swigt__p_Fl_Native_File_Chooser_FLTK_Driver,
  &_swigt__p_Fl_Nice_Slider,
  &_swigt__p_Fl_Offscreen,
  &_swigt__p_Fl_Old_Idle_Handler,
  &_swigt__p_Fl_Output,
  &_swigt__p_Fl_Overlay_Window,
  &_swigt__p_Fl_PDF_File_Surface,
  &_swigt__p_Fl_PNG_Image,
  &_swigt__p_Fl_PNM_Image,
  &_swigt__p_Fl_Pack,
  &_swigt__p_Fl_Paged_Device,
  &_swigt__p_Fl_Pixmap,
  &_swigt__p_Fl_Plugin,
  &_swigt__p_Fl_Plugin_Manager,
  &_swigt__p_Fl_Positioner,
  &_swigt__p_Fl_PostScript_File_Device,
  &_swigt__p_Fl_Preferences,
  &_swigt__p_Fl_Preferences__ID,
  &_swigt__p_Fl_Printer,
  &_swigt__p_Fl_Progress,
  &_swigt__p_Fl_RGB_Image,
  &_swigt__p_Fl_Radio_Button,
  &_swigt__p_Fl_Radio_Light_Button,
  &_swigt__p_Fl_Radio_Round_Button,
  &_swigt__p_Fl_Rect,
  &_swigt__p_Fl_Region,
  &_swigt__p_Fl_Repeat_Button,
  &_swigt__p_Fl_Return_Button,
  &_swigt__p_Fl_Roller,
  &_swigt__p_Fl_Round_Button,
  &_swigt__p_Fl_Round_Clock,
  &_swigt__p_Fl_SVG_File_Surface,
  &_swigt__p_Fl_SVG_Image,
  &_swigt__p_Fl_Scheme_Choice,
  &_swigt__p_Fl_Screen_Driver,
  &_swigt__p_Fl_Scroll,
  &_swigt__p_Fl_Scrollbar,
  &_swigt__p_Fl_Secret_Input,
  &_swigt__p_Fl_Select_Browser,
  &_swigt__p_Fl_Shared_Image,
  &_swigt__p_Fl_Shortcut_Button,
  &_swigt__p_Fl_Simple_Counter,
  &_swigt__p_Fl_Single_Window,
  &_swigt__p_Fl_Slider,
  &_swigt__p_Fl_Spinner,
  &_swigt__p_Fl_Surface_Device,
  &_swigt__p_Fl_Sys_Menu_Bar,
  &_swigt__p_Fl_System_Driver,
  &_swigt__p_Fl_Table,
  &_swigt__p_Fl_Table_Row,
  &_swigt__p_Fl_Tabs,
  &_swigt__p_Fl_Terminal,
  &_swigt__p_Fl_Text_Buffer,
  &_swigt__p_Fl_Text_Display,
  &_swigt__p_Fl_Text_Display__Style_Table_Entry,
  &_swigt__p_Fl_Text_Editor,
  &_swigt__p_Fl_Text_Editor__Key_Binding,
  &_swigt__p_Fl_Text_Selection,
  &_swigt__p_Fl_Tile,
  &_swigt__p_Fl_Tiled_Image,
  &_swigt__p_Fl_Timeout_Handler,
  &_swigt__p_Fl_Timestamp,
  &_swigt__p_Fl_Toggle_Button,
  &_swigt__p_Fl_Tooltip,
  &_swigt__p_Fl_Tree,
  &_swigt__p_Fl_Tree_Item,
  &_swigt__p_Fl_Tree_Item_Array,
  &_swigt__p_Fl_Tree_Prefs,
  &_swigt__p_Fl_Valuator,
  &_swigt__p_Fl_Value_Input,
  &_swigt__p_Fl_Value_Output,
  &_swigt__p_Fl_Value_Slider,
  &_swigt__p_Fl_Vk_Window,
  &_swigt__p_Fl_Widget,
  &_swigt__p_Fl_Widget_Surface,
  &_swigt__p_Fl_Window,
  &_swigt__p_Fl_Wizard,
  &_swigt__p_Fl_X,
  &_swigt__p_Fl_XBM_Image,
  &_swigt__p_Fl_XPM_Image,
  &_swigt__p_Fl__TimeoutData,
  &_swigt__p_Flcc_HueBox,
  &_swigt__p_Flcc_ValueBox,
  &_swigt__p_Flcc_Value_Input,
  &_swigt__p_GLContext,
  &_swigt__p_ListSelect,
  &_swigt__p_Scale_Type,
  &_swigt__p_Style_Table_Entry,
  &_swigt__p_Tick_Position,
  &_swigt__p_Window,
  &_swigt__p_char,
  &_swigt__p_double,
  &_swigt__p_f_int_int_int_int_p_q_const__char_p_void__void,
  &_swigt__p_f_int_int_p_void__void,
  &_swigt__p_f_int_p_Fl_Text_Editor__int,
  &_swigt__p_f_p_FILE__int,
  &_swigt__p_f_p_Fl_File_Chooser_p_void__void,
  &_swigt__p_f_p_Fl_Tree_Item_p_void__void,
  &_swigt__p_f_p_Fl_Widget__void,
  &_swigt__p_f_p_Fl_Widget_long__void,
  &_swigt__p_f_p_Fl_Widget_p_q_const__char__p_char,
  &_swigt__p_f_p_Fl_Widget_p_void__void,
  &_swigt__p_f_p_q_const__char__void,
  &_swigt__p_f_p_q_const__char_int_int_int__void,
  &_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Anim_GIF_Image,
  &_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_BMP_Image,
  &_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Bitmap,
  &_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_GIF_Image,
  &_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_ICO_Image,
  &_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Image,
  &_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_JPEG_Image,
  &_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_PNG_Image,
  &_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_PNM_Image,
  &_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Pixmap,
  &_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_RGB_Image,
  &_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_SVG_Image,
  &_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Shared_Image,
  &_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Tiled_Image,
  &_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_XBM_Image,
  &_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_XPM_Image,
  &_swigt__p_f_p_void_int_int_int_int__void,
  &_swigt__p_f_unsigned_int__void,
  &_swigt__p_f_unsigned_int_unsigned_int_int_int__unsigned_int,
  &_swigt__p_fl_uintptr_t,
  &_swigt__p_float,
  &_swigt__p_int,
  &_swigt__p_p_Fl_Adjuster,
  &_swigt__p_p_Fl_BMP_Image,
  &_swigt__p_p_Fl_Box,
  &_swigt__p_p_Fl_Browser,
  &_swigt__p_p_Fl_Browser_,
  &_swigt__p_p_Fl_Button,
  &_swigt__p_p_Fl_Chart,
  &_swigt__p_p_Fl_Check_Browser,
  &_swigt__p_p_Fl_Check_Button,
  &_swigt__p_p_Fl_Choice,
  &_swigt__p_p_Fl_Clock,
  &_swigt__p_p_Fl_Clock_Output,
  &_swigt__p_p_Fl_Color_Chooser,
  &_swigt__p_p_Fl_Counter,
  &_swigt__p_p_Fl_Dial,
  &_swigt__p_p_Fl_Double_Window,
  &_swigt__p_p_Fl_File_Browser,
  &_swigt__p_p_Fl_File_Input,
  &_swigt__p_p_Fl_Fill_Dial,
  &_swigt__p_p_Fl_Fill_Slider,
  &_swigt__p_p_Fl_Flex,
  &_swigt__p_p_Fl_Float_Input,
  &_swigt__p_p_Fl_Gl_Window,
  &_swigt__p_p_Fl_Grid,
  &_swigt__p_p_Fl_Group,
  &_swigt__p_p_Fl_Help_View,
  &_swigt__p_p_Fl_Hold_Browser,
  &_swigt__p_p_Fl_Hor_Fill_Slider,
  &_swigt__p_p_Fl_Hor_Nice_Slider,
  &_swigt__p_p_Fl_Hor_Slider,
  &_swigt__p_p_Fl_Hor_Value_Slider,
  &_swigt__p_p_Fl_ICO_Image,
  &_swigt__p_p_Fl_Input,
  &_swigt__p_p_Fl_Input_,
  &_swigt__p_p_Fl_Input_Choice,
  &_swigt__p_p_Fl_Int_Input,
  &_swigt__p_p_Fl_JPEG_Image,
  &_swigt__p_p_Fl_Light_Button,
  &_swigt__p_p_Fl_Line_Dial,
  &_swigt__p_p_Fl_Menu_,
  &_swigt__p_p_Fl_Menu_Bar,
  &_swigt__p_p_Fl_Menu_Button,
  &_swigt__p_p_Fl_Menu_Window,
  &_swigt__p_p_Fl_Multi_Browser,
  &_swigt__p_p_Fl_Multiline_Input,
  &_swigt__p_p_Fl_Multiline_Output,
  &_swigt__p_p_Fl_Nice_Slider,
  &_swigt__p_p_Fl_Output,
  &_swigt__p_p_Fl_Overlay_Window,
  &_swigt__p_p_Fl_PNG_Image,
  &_swigt__p_p_Fl_PNM_Image,
  &_swigt__p_p_Fl_Pack,
  &_swigt__p_p_Fl_Positioner,
  &_swigt__p_p_Fl_Progress,
  &_swigt__p_p_Fl_RGB_Image,
  &_swigt__p_p_Fl_Radio_Button,
  &_swigt__p_p_Fl_Radio_Light_Button,
  &_swigt__p_p_Fl_Radio_Round_Button,
  &_swigt__p_p_Fl_Repeat_Button,
  &_swigt__p_p_Fl_Return_Button,
  &_swigt__p_p_Fl_Roller,
  &_swigt__p_p_Fl_Round_Button,
  &_swigt__p_p_Fl_Round_Clock,
  &_swigt__p_p_Fl_SVG_Image,
  &_swigt__p_p_Fl_Scheme_Choice,
  &_swigt__p_p_Fl_Scroll,
  &_swigt__p_p_Fl_Scrollbar,
  &_swigt__p_p_Fl_Secret_Input,
  &_swigt__p_p_Fl_Select_Browser,
  &_swigt__p_p_Fl_Shared_Image,
  &_swigt__p_p_Fl_Shortcut_Button,
  &_swigt__p_p_Fl_Simple_Counter,
  &_swigt__p_p_Fl_Single_Window,
  &_swigt__p_p_Fl_Slider,
  &_swigt__p_p_Fl_Spinner,
  &_swigt__p_p_Fl_Sys_Menu_Bar,
  &_swigt__p_p_Fl_Table,
  &_swigt__p_p_Fl_Table_Row,
  &_swigt__p_p_Fl_Tabs,
  &_swigt__p_p_Fl_Terminal,
  &_swigt__p_p_Fl_Text_Display,
  &_swigt__p_p_Fl_Text_Editor,
  &_swigt__p_p_Fl_Tile,
  &_swigt__p_p_Fl_Toggle_Button,
  &_swigt__p_p_Fl_Tree,
  &_swigt__p_p_Fl_Valuator,
  &_swigt__p_p_Fl_Value_Input,
  &_swigt__p_p_Fl_Value_Output,
  &_swigt__p_p_Fl_Value_Slider,
  &_swigt__p_p_Fl_Widget,
  &_swigt__p_p_Fl_Window,
  &_swigt__p_p_Fl_Wizard,
  &_swigt__p_p_Flcc_HueBox,
  &_swigt__p_p_Flcc_ValueBox,
  &_swigt__p_p_Flcc_Value_Input,
  &_swigt__p_p_ListSelect,
  &_swigt__p_p_char,
  &_swigt__p_p_p_char,
  &_swigt__p_p_p_dirent,
  &_swigt__p_p_void,
  &_swigt__p_short,
  &_swigt__p_std__vectorT_Fl__TimeoutData_t,
  &_swigt__p_unsigned_char,
  &_swigt__p_unsigned_int,
  &_swigt__p_unsigned_long,
  &_swigt__p_unsigned_short,
  &_swigt__p_void,
  &_swigt__p_wchar_t,
  &_swigt__p_window_menu_style_enum,
};

static swig_cast_info _swigc__p_FILE[] = {  {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FL_CHART_ENTRY[] = {  {&_swigt__p_FL_CHART_ENTRY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Abort_Handler[] = {  {&_swigt__p_Fl_Abort_Handler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Adjuster[] = {  {&_swigt__p_Fl_Adjuster, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Anim_GIF_Image[] = {  {&_swigt__p_Fl_Anim_GIF_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Args_Handler[] = {  {&_swigt__p_Fl_Args_Handler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Atclose_Handler[] = {  {&_swigt__p_Fl_Atclose_Handler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Awake_Handler[] = {  {&_swigt__p_Fl_Awake_Handler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_BMP_Image[] = {  {&_swigt__p_Fl_BMP_Image, 0, 0, 0},  {&_swigt__p_Fl_ICO_Image, _p_Fl_ICO_ImageTo_p_Fl_BMP_Image, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Bitmap[] = {  {&_swigt__p_Fl_Bitmap, 0, 0, 0},  {&_swigt__p_Fl_XBM_Image, _p_Fl_XBM_ImageTo_p_Fl_Bitmap, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Box[] = {  {&_swigt__p_Fl_Box, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Box_Draw_F[] = {  {&_swigt__p_Fl_Box_Draw_F, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Box_Draw_Focus_F[] = {  {&_swigt__p_Fl_Box_Draw_Focus_F, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Browser[] = {  {&_swigt__p_Fl_Browser, 0, 0, 0},  {&_swigt__p_Fl_File_Browser, _p_Fl_File_BrowserTo_p_Fl_Browser, 0, 0},  {&_swigt__p_Fl_Hold_Browser, _p_Fl_Hold_BrowserTo_p_Fl_Browser, 0, 0},  {&_swigt__p_Fl_Multi_Browser, _p_Fl_Multi_BrowserTo_p_Fl_Browser, 0, 0},  {&_swigt__p_Fl_Select_Browser, _p_Fl_Select_BrowserTo_p_Fl_Browser, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Browser_[] = {  {&_swigt__p_Fl_Browser_, 0, 0, 0},  {&_swigt__p_Fl_Browser, _p_Fl_BrowserTo_p_Fl_Browser_, 0, 0},  {&_swigt__p_Fl_Check_Browser, _p_Fl_Check_BrowserTo_p_Fl_Browser_, 0, 0},  {&_swigt__p_Fl_File_Browser, _p_Fl_File_BrowserTo_p_Fl_Browser_, 0, 0},  {&_swigt__p_Fl_Hold_Browser, _p_Fl_Hold_BrowserTo_p_Fl_Browser_, 0, 0},  {&_swigt__p_Fl_Multi_Browser, _p_Fl_Multi_BrowserTo_p_Fl_Browser_, 0, 0},  {&_swigt__p_Fl_Select_Browser, _p_Fl_Select_BrowserTo_p_Fl_Browser_, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Button[] = {  {&_swigt__p_Fl_Button, 0, 0, 0},  {&_swigt__p_Fl_Check_Button, _p_Fl_Check_ButtonTo_p_Fl_Button, 0, 0},  {&_swigt__p_Fl_Light_Button, _p_Fl_Light_ButtonTo_p_Fl_Button, 0, 0},  {&_swigt__p_Fl_Radio_Button, _p_Fl_Radio_ButtonTo_p_Fl_Button, 0, 0},  {&_swigt__p_Fl_Radio_Light_Button, _p_Fl_Radio_Light_ButtonTo_p_Fl_Button, 0, 0},  {&_swigt__p_Fl_Radio_Round_Button, _p_Fl_Radio_Round_ButtonTo_p_Fl_Button, 0, 0},  {&_swigt__p_Fl_Repeat_Button, _p_Fl_Repeat_ButtonTo_p_Fl_Button, 0, 0},  {&_swigt__p_Fl_Return_Button, _p_Fl_Return_ButtonTo_p_Fl_Button, 0, 0},  {&_swigt__p_Fl_Round_Button, _p_Fl_Round_ButtonTo_p_Fl_Button, 0, 0},  {&_swigt__p_Fl_Shortcut_Button, _p_Fl_Shortcut_ButtonTo_p_Fl_Button, 0, 0},  {&_swigt__p_Fl_Toggle_Button, _p_Fl_Toggle_ButtonTo_p_Fl_Button, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Callback_User_Data[] = {  {&_swigt__p_Fl_Callback_User_Data, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Chart[] = {  {&_swigt__p_Fl_Chart, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Check_Browser[] = {  {&_swigt__p_Fl_Check_Browser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Check_Button[] = {  {&_swigt__p_Fl_Check_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Choice[] = {  {&_swigt__p_Fl_Choice, 0, 0, 0},  {&_swigt__p_Fl_Scheme_Choice, _p_Fl_Scheme_ChoiceTo_p_Fl_Choice, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Clipboard_Notify_Handler[] = {  {&_swigt__p_Fl_Clipboard_Notify_Handler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Clock[] = {  {&_swigt__p_Fl_Clock, 0, 0, 0},  {&_swigt__p_Fl_Round_Clock, _p_Fl_Round_ClockTo_p_Fl_Clock, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Clock_Output[] = {  {&_swigt__p_Fl_Clock_Output, 0, 0, 0},  {&_swigt__p_Fl_Clock, _p_Fl_ClockTo_p_Fl_Clock_Output, 0, 0},  {&_swigt__p_Fl_Round_Clock, _p_Fl_Round_ClockTo_p_Fl_Clock_Output, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Color_Chooser[] = {  {&_swigt__p_Fl_Color_Chooser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Copy_Surface[] = {  {&_swigt__p_Fl_Copy_Surface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Copy_Surface_Driver[] = {  {&_swigt__p_Fl_Copy_Surface_Driver, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Counter[] = {  {&_swigt__p_Fl_Counter, 0, 0, 0},  {&_swigt__p_Fl_Simple_Counter, _p_Fl_Simple_CounterTo_p_Fl_Counter, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Device_Plugin[] = {  {&_swigt__p_Fl_Device_Plugin, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Dial[] = {  {&_swigt__p_Fl_Dial, 0, 0, 0},  {&_swigt__p_Fl_Fill_Dial, _p_Fl_Fill_DialTo_p_Fl_Dial, 0, 0},  {&_swigt__p_Fl_Line_Dial, _p_Fl_Line_DialTo_p_Fl_Dial, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Display_Device[] = {  {&_swigt__p_Fl_Display_Device, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Double_Window[] = {  {&_swigt__p_Fl_Double_Window, 0, 0, 0},  {&_swigt__p_Fl_Overlay_Window, _p_Fl_Overlay_WindowTo_p_Fl_Double_Window, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_EPS_File_Surface[] = {  {&_swigt__p_Fl_EPS_File_Surface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_End[] = {  {&_swigt__p_Fl_End, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_File_Browser[] = {  {&_swigt__p_Fl_File_Browser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_File_Chooser[] = {  {&_swigt__p_Fl_File_Chooser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_File_Icon[] = {  {&_swigt__p_Fl_File_Icon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_File_Input[] = {  {&_swigt__p_Fl_File_Input, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Fill_Dial[] = {  {&_swigt__p_Fl_Fill_Dial, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Fill_Slider[] = {  {&_swigt__p_Fl_Fill_Slider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Flex[] = {  {&_swigt__p_Fl_Flex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Float_Input[] = {  {&_swigt__p_Fl_Float_Input, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_GIF_Image[] = {  {&_swigt__p_Fl_GIF_Image, 0, 0, 0},  {&_swigt__p_Fl_Anim_GIF_Image, _p_Fl_Anim_GIF_ImageTo_p_Fl_GIF_Image, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Gl_Window[] = {  {&_swigt__p_Fl_Gl_Window, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Graphics_Driver[] = {  {&_swigt__p_Fl_Graphics_Driver, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Grid[] = {  {&_swigt__p_Fl_Grid, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Grid__Cell[] = {  {&_swigt__p_Fl_Grid__Cell, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Group[] = {  {&_swigt__p_Fl_Group, 0, 0, 0},  {&_swigt__p_Fl_Browser, _p_Fl_BrowserTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Browser_, _p_Fl_Browser_To_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Check_Browser, _p_Fl_Check_BrowserTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Color_Chooser, _p_Fl_Color_ChooserTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Double_Window, _p_Fl_Double_WindowTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_File_Browser, _p_Fl_File_BrowserTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Flex, _p_Fl_FlexTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Gl_Window, _p_Fl_Gl_WindowTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Grid, _p_Fl_GridTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Help_View, _p_Fl_Help_ViewTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Hold_Browser, _p_Fl_Hold_BrowserTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Input_Choice, _p_Fl_Input_ChoiceTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Menu_Window, _p_Fl_Menu_WindowTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Multi_Browser, _p_Fl_Multi_BrowserTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Overlay_Window, _p_Fl_Overlay_WindowTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Pack, _p_Fl_PackTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Scroll, _p_Fl_ScrollTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Select_Browser, _p_Fl_Select_BrowserTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Single_Window, _p_Fl_Single_WindowTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Spinner, _p_Fl_SpinnerTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Table, _p_Fl_TableTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Table_Row, _p_Fl_Table_RowTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Tabs, _p_Fl_TabsTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Terminal, _p_Fl_TerminalTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Text_Display, _p_Fl_Text_DisplayTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Text_Editor, _p_Fl_Text_EditorTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Tile, _p_Fl_TileTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Tree, _p_Fl_TreeTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Window, _p_Fl_WindowTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Wizard, _p_Fl_WizardTo_p_Fl_Group, 0, 0},  {&_swigt__p_ListSelect, _p_ListSelectTo_p_Fl_Group, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Help_Dialog[] = {  {&_swigt__p_Fl_Help_Dialog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Help_View[] = {  {&_swigt__p_Fl_Help_View, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Hold_Browser[] = {  {&_swigt__p_Fl_Hold_Browser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Hor_Fill_Slider[] = {  {&_swigt__p_Fl_Hor_Fill_Slider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Hor_Nice_Slider[] = {  {&_swigt__p_Fl_Hor_Nice_Slider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Hor_Slider[] = {  {&_swigt__p_Fl_Hor_Slider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Hor_Value_Slider[] = {  {&_swigt__p_Fl_Hor_Value_Slider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_ICO_Image[] = {  {&_swigt__p_Fl_ICO_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_ICO_Image__IconDirEntry[] = {  {&_swigt__p_Fl_ICO_Image__IconDirEntry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Idle_Handler[] = {  {&_swigt__p_Fl_Idle_Handler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Image[] = {  {&_swigt__p_Fl_Image, 0, 0, 0},  {&_swigt__p_Fl_Anim_GIF_Image, _p_Fl_Anim_GIF_ImageTo_p_Fl_Image, 0, 0},  {&_swigt__p_Fl_BMP_Image, _p_Fl_BMP_ImageTo_p_Fl_Image, 0, 0},  {&_swigt__p_Fl_Bitmap, _p_Fl_BitmapTo_p_Fl_Image, 0, 0},  {&_swigt__p_Fl_GIF_Image, _p_Fl_GIF_ImageTo_p_Fl_Image, 0, 0},  {&_swigt__p_Fl_ICO_Image, _p_Fl_ICO_ImageTo_p_Fl_Image, 0, 0},  {&_swigt__p_Fl_JPEG_Image, _p_Fl_JPEG_ImageTo_p_Fl_Image, 0, 0},  {&_swigt__p_Fl_PNG_Image, _p_Fl_PNG_ImageTo_p_Fl_Image, 0, 0},  {&_swigt__p_Fl_PNM_Image, _p_Fl_PNM_ImageTo_p_Fl_Image, 0, 0},  {&_swigt__p_Fl_Pixmap, _p_Fl_PixmapTo_p_Fl_Image, 0, 0},  {&_swigt__p_Fl_RGB_Image, _p_Fl_RGB_ImageTo_p_Fl_Image, 0, 0},  {&_swigt__p_Fl_SVG_Image, _p_Fl_SVG_ImageTo_p_Fl_Image, 0, 0},  {&_swigt__p_Fl_Shared_Image, _p_Fl_Shared_ImageTo_p_Fl_Image, 0, 0},  {&_swigt__p_Fl_Tiled_Image, _p_Fl_Tiled_ImageTo_p_Fl_Image, 0, 0},  {&_swigt__p_Fl_XBM_Image, _p_Fl_XBM_ImageTo_p_Fl_Image, 0, 0},  {&_swigt__p_Fl_XPM_Image, _p_Fl_XPM_ImageTo_p_Fl_Image, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Image_Surface[] = {  {&_swigt__p_Fl_Image_Surface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Input[] = {  {&_swigt__p_Fl_Input, 0, 0, 0},  {&_swigt__p_Fl_File_Input, _p_Fl_File_InputTo_p_Fl_Input, 0, 0},  {&_swigt__p_Fl_Float_Input, _p_Fl_Float_InputTo_p_Fl_Input, 0, 0},  {&_swigt__p_Fl_Int_Input, _p_Fl_Int_InputTo_p_Fl_Input, 0, 0},  {&_swigt__p_Fl_Multiline_Input, _p_Fl_Multiline_InputTo_p_Fl_Input, 0, 0},  {&_swigt__p_Fl_Multiline_Output, _p_Fl_Multiline_OutputTo_p_Fl_Input, 0, 0},  {&_swigt__p_Fl_Output, _p_Fl_OutputTo_p_Fl_Input, 0, 0},  {&_swigt__p_Fl_Secret_Input, _p_Fl_Secret_InputTo_p_Fl_Input, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Input_[] = {  {&_swigt__p_Fl_Input_, 0, 0, 0},  {&_swigt__p_Fl_File_Input, _p_Fl_File_InputTo_p_Fl_Input_, 0, 0},  {&_swigt__p_Fl_Float_Input, _p_Fl_Float_InputTo_p_Fl_Input_, 0, 0},  {&_swigt__p_Fl_Input, _p_Fl_InputTo_p_Fl_Input_, 0, 0},  {&_swigt__p_Fl_Int_Input, _p_Fl_Int_InputTo_p_Fl_Input_, 0, 0},  {&_swigt__p_Fl_Multiline_Input, _p_Fl_Multiline_InputTo_p_Fl_Input_, 0, 0},  {&_swigt__p_Fl_Multiline_Output, _p_Fl_Multiline_OutputTo_p_Fl_Input_, 0, 0},  {&_swigt__p_Fl_Output, _p_Fl_OutputTo_p_Fl_Input_, 0, 0},  {&_swigt__p_Fl_Secret_Input, _p_Fl_Secret_InputTo_p_Fl_Input_, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Input_Choice[] = {  {&_swigt__p_Fl_Input_Choice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Int_Input[] = {  {&_swigt__p_Fl_Int_Input, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_JPEG_Image[] = {  {&_swigt__p_Fl_JPEG_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Label[] = {  {&_swigt__p_Fl_Label, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Label_Draw_F[] = {  {&_swigt__p_Fl_Label_Draw_F, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Label_Measure_F[] = {  {&_swigt__p_Fl_Label_Measure_F, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Light_Button[] = {  {&_swigt__p_Fl_Light_Button, 0, 0, 0},  {&_swigt__p_Fl_Check_Button, _p_Fl_Check_ButtonTo_p_Fl_Light_Button, 0, 0},  {&_swigt__p_Fl_Radio_Light_Button, _p_Fl_Radio_Light_ButtonTo_p_Fl_Light_Button, 0, 0},  {&_swigt__p_Fl_Radio_Round_Button, _p_Fl_Radio_Round_ButtonTo_p_Fl_Light_Button, 0, 0},  {&_swigt__p_Fl_Round_Button, _p_Fl_Round_ButtonTo_p_Fl_Light_Button, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Line_Dial[] = {  {&_swigt__p_Fl_Line_Dial, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Menu_[] = {  {&_swigt__p_Fl_Menu_, 0, 0, 0},  {&_swigt__p_Fl_Choice, _p_Fl_ChoiceTo_p_Fl_Menu_, 0, 0},  {&_swigt__p_Fl_Menu_Bar, _p_Fl_Menu_BarTo_p_Fl_Menu_, 0, 0},  {&_swigt__p_Fl_Menu_Button, _p_Fl_Menu_ButtonTo_p_Fl_Menu_, 0, 0},  {&_swigt__p_Fl_Scheme_Choice, _p_Fl_Scheme_ChoiceTo_p_Fl_Menu_, 0, 0},  {&_swigt__p_Fl_Sys_Menu_Bar, _p_Fl_Sys_Menu_BarTo_p_Fl_Menu_, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Menu_Bar[] = {  {&_swigt__p_Fl_Menu_Bar, 0, 0, 0},  {&_swigt__p_Fl_Sys_Menu_Bar, _p_Fl_Sys_Menu_BarTo_p_Fl_Menu_Bar, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Menu_Button[] = {  {&_swigt__p_Fl_Menu_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Menu_Item[] = {  {&_swigt__p_Fl_Menu_Item, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Menu_Window[] = {  {&_swigt__p_Fl_Menu_Window, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Multi_Browser[] = {  {&_swigt__p_Fl_Multi_Browser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Multi_Label[] = {  {&_swigt__p_Fl_Multi_Label, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Multiline_Input[] = {  {&_swigt__p_Fl_Multiline_Input, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Multiline_Output[] = {  {&_swigt__p_Fl_Multiline_Output, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Native_File_Chooser[] = {  {&_swigt__p_Fl_Native_File_Chooser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Native_File_Chooser_FLTK_Driver[] = {{&_swigt__p_Fl_Native_File_Chooser_FLTK_Driver, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Native_File_Chooser_Driver[] = {  {&_swigt__p_Fl_Native_File_Chooser_Driver, 0, 0, 0},  {&_swigt__p_Fl_Native_File_Chooser_FLTK_Driver, _p_Fl_Native_File_Chooser_FLTK_DriverTo_p_Fl_Native_File_Chooser_Driver, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Nice_Slider[] = {  {&_swigt__p_Fl_Nice_Slider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Offscreen[] = {  {&_swigt__p_Fl_Offscreen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Old_Idle_Handler[] = {  {&_swigt__p_Fl_Old_Idle_Handler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Output[] = {  {&_swigt__p_Fl_Output, 0, 0, 0},  {&_swigt__p_Fl_Multiline_Output, _p_Fl_Multiline_OutputTo_p_Fl_Output, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Overlay_Window[] = {  {&_swigt__p_Fl_Overlay_Window, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_PDF_File_Surface[] = {  {&_swigt__p_Fl_PDF_File_Surface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_PNG_Image[] = {  {&_swigt__p_Fl_PNG_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_PNM_Image[] = {  {&_swigt__p_Fl_PNM_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Pack[] = {  {&_swigt__p_Fl_Pack, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Paged_Device[] = {  {&_swigt__p_Fl_Paged_Device, 0, 0, 0},  {&_swigt__p_Fl_PDF_File_Surface, _p_Fl_PDF_File_SurfaceTo_p_Fl_Paged_Device, 0, 0},  {&_swigt__p_Fl_PostScript_File_Device, _p_Fl_PostScript_File_DeviceTo_p_Fl_Paged_Device, 0, 0},  {&_swigt__p_Fl_Printer, _p_Fl_PrinterTo_p_Fl_Paged_Device, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Pixmap[] = {  {&_swigt__p_Fl_Pixmap, 0, 0, 0},  {&_swigt__p_Fl_Anim_GIF_Image, _p_Fl_Anim_GIF_ImageTo_p_Fl_Pixmap, 0, 0},  {&_swigt__p_Fl_GIF_Image, _p_Fl_GIF_ImageTo_p_Fl_Pixmap, 0, 0},  {&_swigt__p_Fl_XPM_Image, _p_Fl_XPM_ImageTo_p_Fl_Pixmap, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Plugin[] = {  {&_swigt__p_Fl_Plugin, 0, 0, 0},  {&_swigt__p_Fl_Device_Plugin, _p_Fl_Device_PluginTo_p_Fl_Plugin, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Plugin_Manager[] = {  {&_swigt__p_Fl_Plugin_Manager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Positioner[] = {  {&_swigt__p_Fl_Positioner, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_PostScript_File_Device[] = {  {&_swigt__p_Fl_PostScript_File_Device, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Preferences[] = {  {&_swigt__p_Fl_Preferences, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Preferences__ID[] = {  {&_swigt__p_Fl_Preferences__ID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Printer[] = {  {&_swigt__p_Fl_Printer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Progress[] = {  {&_swigt__p_Fl_Progress, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_RGB_Image[] = {  {&_swigt__p_Fl_RGB_Image, 0, 0, 0},  {&_swigt__p_Fl_BMP_Image, _p_Fl_BMP_ImageTo_p_Fl_RGB_Image, 0, 0},  {&_swigt__p_Fl_ICO_Image, _p_Fl_ICO_ImageTo_p_Fl_RGB_Image, 0, 0},  {&_swigt__p_Fl_JPEG_Image, _p_Fl_JPEG_ImageTo_p_Fl_RGB_Image, 0, 0},  {&_swigt__p_Fl_PNG_Image, _p_Fl_PNG_ImageTo_p_Fl_RGB_Image, 0, 0},  {&_swigt__p_Fl_PNM_Image, _p_Fl_PNM_ImageTo_p_Fl_RGB_Image, 0, 0},  {&_swigt__p_Fl_SVG_Image, _p_Fl_SVG_ImageTo_p_Fl_RGB_Image, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Radio_Button[] = {  {&_swigt__p_Fl_Radio_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Radio_Light_Button[] = {  {&_swigt__p_Fl_Radio_Light_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Radio_Round_Button[] = {  {&_swigt__p_Fl_Radio_Round_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Rect[] = {  {&_swigt__p_Fl_Rect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Region[] = {  {&_swigt__p_Fl_Region, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Repeat_Button[] = {  {&_swigt__p_Fl_Repeat_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Return_Button[] = {  {&_swigt__p_Fl_Return_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Roller[] = {  {&_swigt__p_Fl_Roller, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Round_Button[] = {  {&_swigt__p_Fl_Round_Button, 0, 0, 0},  {&_swigt__p_Fl_Radio_Round_Button, _p_Fl_Radio_Round_ButtonTo_p_Fl_Round_Button, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Round_Clock[] = {  {&_swigt__p_Fl_Round_Clock, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_SVG_File_Surface[] = {  {&_swigt__p_Fl_SVG_File_Surface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_SVG_Image[] = {  {&_swigt__p_Fl_SVG_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Scheme_Choice[] = {  {&_swigt__p_Fl_Scheme_Choice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Screen_Driver[] = {  {&_swigt__p_Fl_Screen_Driver, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Scroll[] = {  {&_swigt__p_Fl_Scroll, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Scrollbar[] = {  {&_swigt__p_Fl_Scrollbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Secret_Input[] = {  {&_swigt__p_Fl_Secret_Input, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Select_Browser[] = {  {&_swigt__p_Fl_Select_Browser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Shared_Image[] = {  {&_swigt__p_Fl_Shared_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Shortcut_Button[] = {  {&_swigt__p_Fl_Shortcut_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Simple_Counter[] = {  {&_swigt__p_Fl_Simple_Counter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Single_Window[] = {  {&_swigt__p_Fl_Single_Window, 0, 0, 0},  {&_swigt__p_Fl_Menu_Window, _p_Fl_Menu_WindowTo_p_Fl_Single_Window, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Slider[] = {  {&_swigt__p_Fl_Slider, 0, 0, 0},  {&_swigt__p_Fl_Fill_Slider, _p_Fl_Fill_SliderTo_p_Fl_Slider, 0, 0},  {&_swigt__p_Fl_Hor_Fill_Slider, _p_Fl_Hor_Fill_SliderTo_p_Fl_Slider, 0, 0},  {&_swigt__p_Fl_Hor_Nice_Slider, _p_Fl_Hor_Nice_SliderTo_p_Fl_Slider, 0, 0},  {&_swigt__p_Fl_Hor_Slider, _p_Fl_Hor_SliderTo_p_Fl_Slider, 0, 0},  {&_swigt__p_Fl_Hor_Value_Slider, _p_Fl_Hor_Value_SliderTo_p_Fl_Slider, 0, 0},  {&_swigt__p_Fl_Nice_Slider, _p_Fl_Nice_SliderTo_p_Fl_Slider, 0, 0},  {&_swigt__p_Fl_Scrollbar, _p_Fl_ScrollbarTo_p_Fl_Slider, 0, 0},  {&_swigt__p_Fl_Value_Slider, _p_Fl_Value_SliderTo_p_Fl_Slider, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Spinner[] = {  {&_swigt__p_Fl_Spinner, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Image_Surface_Driver[] = {{&_swigt__p_Fl_Image_Surface_Driver, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Surface_Device[] = {  {&_swigt__p_Fl_Surface_Device, 0, 0, 0},  {&_swigt__p_Fl_Display_Device, _p_Fl_Display_DeviceTo_p_Fl_Surface_Device, 0, 0},  {&_swigt__p_Fl_EPS_File_Surface, _p_Fl_EPS_File_SurfaceTo_p_Fl_Surface_Device, 0, 0},  {&_swigt__p_Fl_Image_Surface, _p_Fl_Image_SurfaceTo_p_Fl_Surface_Device, 0, 0},  {&_swigt__p_Fl_Image_Surface_Driver, _p_Fl_Image_Surface_DriverTo_p_Fl_Surface_Device, 0, 0},  {&_swigt__p_Fl_PDF_File_Surface, _p_Fl_PDF_File_SurfaceTo_p_Fl_Surface_Device, 0, 0},  {&_swigt__p_Fl_Paged_Device, _p_Fl_Paged_DeviceTo_p_Fl_Surface_Device, 0, 0},  {&_swigt__p_Fl_PostScript_File_Device, _p_Fl_PostScript_File_DeviceTo_p_Fl_Surface_Device, 0, 0},  {&_swigt__p_Fl_Printer, _p_Fl_PrinterTo_p_Fl_Surface_Device, 0, 0},  {&_swigt__p_Fl_SVG_File_Surface, _p_Fl_SVG_File_SurfaceTo_p_Fl_Surface_Device, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Sys_Menu_Bar[] = {  {&_swigt__p_Fl_Sys_Menu_Bar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_System_Driver[] = {  {&_swigt__p_Fl_System_Driver, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Table[] = {  {&_swigt__p_Fl_Table, 0, 0, 0},  {&_swigt__p_Fl_Table_Row, _p_Fl_Table_RowTo_p_Fl_Table, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Table_Row[] = {  {&_swigt__p_Fl_Table_Row, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Tabs[] = {  {&_swigt__p_Fl_Tabs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Terminal[] = {  {&_swigt__p_Fl_Terminal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Text_Buffer[] = {  {&_swigt__p_Fl_Text_Buffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Text_Display[] = {  {&_swigt__p_Fl_Text_Display, 0, 0, 0},  {&_swigt__p_Fl_Text_Editor, _p_Fl_Text_EditorTo_p_Fl_Text_Display, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Text_Display__Style_Table_Entry[] = {  {&_swigt__p_Fl_Text_Display__Style_Table_Entry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Text_Editor[] = {  {&_swigt__p_Fl_Text_Editor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Text_Editor__Key_Binding[] = {  {&_swigt__p_Fl_Text_Editor__Key_Binding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Text_Selection[] = {  {&_swigt__p_Fl_Text_Selection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Tile[] = {  {&_swigt__p_Fl_Tile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Tiled_Image[] = {  {&_swigt__p_Fl_Tiled_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Timeout_Handler[] = {  {&_swigt__p_Fl_Timeout_Handler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Timestamp[] = {  {&_swigt__p_Fl_Timestamp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Toggle_Button[] = {  {&_swigt__p_Fl_Toggle_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Tooltip[] = {  {&_swigt__p_Fl_Tooltip, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Tree[] = {  {&_swigt__p_Fl_Tree, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Tree_Item[] = {  {&_swigt__p_Fl_Tree_Item, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Tree_Item_Array[] = {  {&_swigt__p_Fl_Tree_Item_Array, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Tree_Prefs[] = {  {&_swigt__p_Fl_Tree_Prefs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Valuator[] = {  {&_swigt__p_Fl_Valuator, 0, 0, 0},  {&_swigt__p_Fl_Adjuster, _p_Fl_AdjusterTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Counter, _p_Fl_CounterTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Dial, _p_Fl_DialTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Fill_Dial, _p_Fl_Fill_DialTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Fill_Slider, _p_Fl_Fill_SliderTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Hor_Fill_Slider, _p_Fl_Hor_Fill_SliderTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Hor_Nice_Slider, _p_Fl_Hor_Nice_SliderTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Hor_Slider, _p_Fl_Hor_SliderTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Hor_Value_Slider, _p_Fl_Hor_Value_SliderTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Line_Dial, _p_Fl_Line_DialTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Nice_Slider, _p_Fl_Nice_SliderTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Roller, _p_Fl_RollerTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Scrollbar, _p_Fl_ScrollbarTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Simple_Counter, _p_Fl_Simple_CounterTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Slider, _p_Fl_SliderTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Value_Input, _p_Fl_Value_InputTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Value_Output, _p_Fl_Value_OutputTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Value_Slider, _p_Fl_Value_SliderTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Flcc_Value_Input, _p_Flcc_Value_InputTo_p_Fl_Valuator, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Value_Input[] = {  {&_swigt__p_Fl_Value_Input, 0, 0, 0},  {&_swigt__p_Flcc_Value_Input, _p_Flcc_Value_InputTo_p_Fl_Value_Input, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Value_Output[] = {  {&_swigt__p_Fl_Value_Output, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Value_Slider[] = {  {&_swigt__p_Fl_Value_Slider, 0, 0, 0},  {&_swigt__p_Fl_Hor_Value_Slider, _p_Fl_Hor_Value_SliderTo_p_Fl_Value_Slider, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Vk_Window[] = {  {&_swigt__p_Fl_Vk_Window, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Widget[] = {  {&_swigt__p_Fl_Widget, 0, 0, 0},  {&_swigt__p_Fl_Adjuster, _p_Fl_AdjusterTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Box, _p_Fl_BoxTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Browser, _p_Fl_BrowserTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Browser_, _p_Fl_Browser_To_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Button, _p_Fl_ButtonTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Chart, _p_Fl_ChartTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Check_Browser, _p_Fl_Check_BrowserTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Check_Button, _p_Fl_Check_ButtonTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Choice, _p_Fl_ChoiceTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Clock, _p_Fl_ClockTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Clock_Output, _p_Fl_Clock_OutputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Color_Chooser, _p_Fl_Color_ChooserTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Counter, _p_Fl_CounterTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Dial, _p_Fl_DialTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Double_Window, _p_Fl_Double_WindowTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_File_Browser, _p_Fl_File_BrowserTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_File_Input, _p_Fl_File_InputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Fill_Dial, _p_Fl_Fill_DialTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Fill_Slider, _p_Fl_Fill_SliderTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Flex, _p_Fl_FlexTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Float_Input, _p_Fl_Float_InputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Gl_Window, _p_Fl_Gl_WindowTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Grid, _p_Fl_GridTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Group, _p_Fl_GroupTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Help_View, _p_Fl_Help_ViewTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Hold_Browser, _p_Fl_Hold_BrowserTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Hor_Fill_Slider, _p_Fl_Hor_Fill_SliderTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Hor_Nice_Slider, _p_Fl_Hor_Nice_SliderTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Hor_Slider, _p_Fl_Hor_SliderTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Hor_Value_Slider, _p_Fl_Hor_Value_SliderTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Input, _p_Fl_InputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Input_, _p_Fl_Input_To_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Input_Choice, _p_Fl_Input_ChoiceTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Int_Input, _p_Fl_Int_InputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Light_Button, _p_Fl_Light_ButtonTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Line_Dial, _p_Fl_Line_DialTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Menu_, _p_Fl_Menu_To_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Menu_Bar, _p_Fl_Menu_BarTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Menu_Button, _p_Fl_Menu_ButtonTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Menu_Window, _p_Fl_Menu_WindowTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Multi_Browser, _p_Fl_Multi_BrowserTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Multiline_Input, _p_Fl_Multiline_InputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Multiline_Output, _p_Fl_Multiline_OutputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Nice_Slider, _p_Fl_Nice_SliderTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Output, _p_Fl_OutputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Overlay_Window, _p_Fl_Overlay_WindowTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Pack, _p_Fl_PackTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Positioner, _p_Fl_PositionerTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Progress, _p_Fl_ProgressTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Radio_Button, _p_Fl_Radio_ButtonTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Radio_Light_Button, _p_Fl_Radio_Light_ButtonTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Radio_Round_Button, _p_Fl_Radio_Round_ButtonTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Repeat_Button, _p_Fl_Repeat_ButtonTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Return_Button, _p_Fl_Return_ButtonTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Roller, _p_Fl_RollerTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Round_Button, _p_Fl_Round_ButtonTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Round_Clock, _p_Fl_Round_ClockTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Scheme_Choice, _p_Fl_Scheme_ChoiceTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Scroll, _p_Fl_ScrollTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Scrollbar, _p_Fl_ScrollbarTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Secret_Input, _p_Fl_Secret_InputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Select_Browser, _p_Fl_Select_BrowserTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Shortcut_Button, _p_Fl_Shortcut_ButtonTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Simple_Counter, _p_Fl_Simple_CounterTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Single_Window, _p_Fl_Single_WindowTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Slider, _p_Fl_SliderTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Spinner, _p_Fl_SpinnerTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Sys_Menu_Bar, _p_Fl_Sys_Menu_BarTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Table, _p_Fl_TableTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Table_Row, _p_Fl_Table_RowTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Tabs, _p_Fl_TabsTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Terminal, _p_Fl_TerminalTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Text_Display, _p_Fl_Text_DisplayTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Text_Editor, _p_Fl_Text_EditorTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Tile, _p_Fl_TileTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Toggle_Button, _p_Fl_Toggle_ButtonTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Tree, _p_Fl_TreeTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Valuator, _p_Fl_ValuatorTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Value_Input, _p_Fl_Value_InputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Value_Output, _p_Fl_Value_OutputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Value_Slider, _p_Fl_Value_SliderTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Window, _p_Fl_WindowTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Wizard, _p_Fl_WizardTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Flcc_HueBox, _p_Flcc_HueBoxTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Flcc_ValueBox, _p_Flcc_ValueBoxTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Flcc_Value_Input, _p_Flcc_Value_InputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_ListSelect, _p_ListSelectTo_p_Fl_Widget, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Widget_Surface[] = {  {&_swigt__p_Fl_Widget_Surface, 0, 0, 0},  {&_swigt__p_Fl_Copy_Surface, _p_Fl_Copy_SurfaceTo_p_Fl_Widget_Surface, 0, 0},  {&_swigt__p_Fl_Copy_Surface_Driver, _p_Fl_Copy_Surface_DriverTo_p_Fl_Widget_Surface, 0, 0},  {&_swigt__p_Fl_EPS_File_Surface, _p_Fl_EPS_File_SurfaceTo_p_Fl_Widget_Surface, 0, 0},  {&_swigt__p_Fl_Image_Surface, _p_Fl_Image_SurfaceTo_p_Fl_Widget_Surface, 0, 0},  {&_swigt__p_Fl_Image_Surface_Driver, _p_Fl_Image_Surface_DriverTo_p_Fl_Widget_Surface, 0, 0},  {&_swigt__p_Fl_PDF_File_Surface, _p_Fl_PDF_File_SurfaceTo_p_Fl_Widget_Surface, 0, 0},  {&_swigt__p_Fl_Paged_Device, _p_Fl_Paged_DeviceTo_p_Fl_Widget_Surface, 0, 0},  {&_swigt__p_Fl_PostScript_File_Device, _p_Fl_PostScript_File_DeviceTo_p_Fl_Widget_Surface, 0, 0},  {&_swigt__p_Fl_Printer, _p_Fl_PrinterTo_p_Fl_Widget_Surface, 0, 0},  {&_swigt__p_Fl_SVG_File_Surface, _p_Fl_SVG_File_SurfaceTo_p_Fl_Widget_Surface, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Window[] = {  {&_swigt__p_Fl_Window, 0, 0, 0},  {&_swigt__p_Fl_Double_Window, _p_Fl_Double_WindowTo_p_Fl_Window, 0, 0},  {&_swigt__p_Fl_Gl_Window, _p_Fl_Gl_WindowTo_p_Fl_Window, 0, 0},  {&_swigt__p_Fl_Menu_Window, _p_Fl_Menu_WindowTo_p_Fl_Window, 0, 0},  {&_swigt__p_Fl_Overlay_Window, _p_Fl_Overlay_WindowTo_p_Fl_Window, 0, 0},  {&_swigt__p_Fl_Single_Window, _p_Fl_Single_WindowTo_p_Fl_Window, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Wizard[] = {  {&_swigt__p_Fl_Wizard, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_X[] = {  {&_swigt__p_Fl_X, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_XBM_Image[] = {  {&_swigt__p_Fl_XBM_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_XPM_Image[] = {  {&_swigt__p_Fl_XPM_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl__TimeoutData[] = {  {&_swigt__p_Fl__TimeoutData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Flcc_HueBox[] = {  {&_swigt__p_Flcc_HueBox, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Flcc_ValueBox[] = {  {&_swigt__p_Flcc_ValueBox, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Flcc_Value_Input[] = {  {&_swigt__p_Flcc_Value_Input, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GLContext[] = {  {&_swigt__p_GLContext, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListSelect[] = {  {&_swigt__p_ListSelect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Scale_Type[] = {  {&_swigt__p_Scale_Type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Style_Table_Entry[] = {  {&_swigt__p_Style_Table_Entry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Tick_Position[] = {  {&_swigt__p_Tick_Position, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Window[] = {  {&_swigt__p_Window, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_int_int_int_int_p_q_const__char_p_void__void[] = {  {&_swigt__p_f_int_int_int_int_p_q_const__char_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_int_int_p_void__void[] = {  {&_swigt__p_f_int_int_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_int_p_Fl_Text_Editor__int[] = {  {&_swigt__p_f_int_p_Fl_Text_Editor__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_FILE__int[] = {  {&_swigt__p_f_p_FILE__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_Fl_File_Chooser_p_void__void[] = {  {&_swigt__p_f_p_Fl_File_Chooser_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_Fl_Tree_Item_p_void__void[] = {  {&_swigt__p_f_p_Fl_Tree_Item_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_Fl_Widget__void[] = {  {&_swigt__p_f_p_Fl_Widget__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_Fl_Widget_long__void[] = {  {&_swigt__p_f_p_Fl_Widget_long__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_Fl_Widget_p_q_const__char__p_char[] = {  {&_swigt__p_f_p_Fl_Widget_p_q_const__char__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_Fl_Widget_p_void__void[] = {  {&_swigt__p_f_p_Fl_Widget_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char__void[] = {  {&_swigt__p_f_p_q_const__char__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_int_int_int__void[] = {  {&_swigt__p_f_p_q_const__char_int_int_int__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_Anim_GIF_Image[] = {{&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Anim_GIF_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_BMP_Image[] = {{&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_BMP_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_Bitmap[] = {{&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Bitmap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_GIF_Image[] = {{&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_GIF_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_ICO_Image[] = {{&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_ICO_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_JPEG_Image[] = {{&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_JPEG_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_PNG_Image[] = {{&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_PNG_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_PNM_Image[] = {{&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_PNM_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_Pixmap[] = {{&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Pixmap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_RGB_Image[] = {{&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_RGB_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_SVG_Image[] = {{&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_SVG_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_Shared_Image[] = {{&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Shared_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_Tiled_Image[] = {{&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Tiled_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_XBM_Image[] = {{&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_XBM_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_XPM_Image[] = {{&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_XPM_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_Image[] = {  {&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Image, 0, 0, 0},  {&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Anim_GIF_Image, _p_f_p_q_const__char_p_uchar_int__p_Fl_Anim_GIF_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image, 0, 0},  {&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_BMP_Image, _p_f_p_q_const__char_p_uchar_int__p_Fl_BMP_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image, 0, 0},  {&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Bitmap, _p_f_p_q_const__char_p_uchar_int__p_Fl_BitmapTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image, 0, 0},  {&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_GIF_Image, _p_f_p_q_const__char_p_uchar_int__p_Fl_GIF_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image, 0, 0},  {&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_ICO_Image, _p_f_p_q_const__char_p_uchar_int__p_Fl_ICO_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image, 0, 0},  {&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_JPEG_Image, _p_f_p_q_const__char_p_uchar_int__p_Fl_JPEG_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image, 0, 0},  {&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_PNG_Image, _p_f_p_q_const__char_p_uchar_int__p_Fl_PNG_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image, 0, 0},  {&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_PNM_Image, _p_f_p_q_const__char_p_uchar_int__p_Fl_PNM_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image, 0, 0},  {&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Pixmap, _p_f_p_q_const__char_p_uchar_int__p_Fl_PixmapTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image, 0, 0},  {&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_RGB_Image, _p_f_p_q_const__char_p_uchar_int__p_Fl_RGB_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image, 0, 0},  {&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_SVG_Image, _p_f_p_q_const__char_p_uchar_int__p_Fl_SVG_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image, 0, 0},  {&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Shared_Image, _p_f_p_q_const__char_p_uchar_int__p_Fl_Shared_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image, 0, 0},  {&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_Tiled_Image, _p_f_p_q_const__char_p_uchar_int__p_Fl_Tiled_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image, 0, 0},  {&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_XBM_Image, _p_f_p_q_const__char_p_uchar_int__p_Fl_XBM_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image, 0, 0},  {&_swigt__p_f_p_q_const__char_p_uchar_int__p_Fl_XPM_Image, _p_f_p_q_const__char_p_uchar_int__p_Fl_XPM_ImageTo_p_f_p_q_const__char_p_uchar_int__p_Fl_Image, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_int_int_int_int__void[] = {  {&_swigt__p_f_p_void_int_int_int_int__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_unsigned_int__void[] = {  {&_swigt__p_f_unsigned_int__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_unsigned_int_unsigned_int_int_int__unsigned_int[] = {  {&_swigt__p_f_unsigned_int_unsigned_int_int_int__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_fl_uintptr_t[] = {  {&_swigt__p_fl_uintptr_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_BMP_Image[] = {{&_swigt__p_p_Fl_BMP_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_ICO_Image[] = {{&_swigt__p_p_Fl_ICO_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_JPEG_Image[] = {{&_swigt__p_p_Fl_JPEG_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_PNG_Image[] = {{&_swigt__p_p_Fl_PNG_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_PNM_Image[] = {{&_swigt__p_p_Fl_PNM_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_SVG_Image[] = {{&_swigt__p_p_Fl_SVG_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_RGB_Image[] = {  {&_swigt__p_p_Fl_RGB_Image, 0, 0, 0},  {&_swigt__p_p_Fl_BMP_Image, _p_p_Fl_BMP_ImageTo_p_p_Fl_RGB_Image, 0, 0},  {&_swigt__p_p_Fl_ICO_Image, _p_p_Fl_ICO_ImageTo_p_p_Fl_RGB_Image, 0, 0},  {&_swigt__p_p_Fl_JPEG_Image, _p_p_Fl_JPEG_ImageTo_p_p_Fl_RGB_Image, 0, 0},  {&_swigt__p_p_Fl_PNG_Image, _p_p_Fl_PNG_ImageTo_p_p_Fl_RGB_Image, 0, 0},  {&_swigt__p_p_Fl_PNM_Image, _p_p_Fl_PNM_ImageTo_p_p_Fl_RGB_Image, 0, 0},  {&_swigt__p_p_Fl_SVG_Image, _p_p_Fl_SVG_ImageTo_p_p_Fl_RGB_Image, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Shared_Image[] = {  {&_swigt__p_p_Fl_Shared_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Adjuster[] = {{&_swigt__p_p_Fl_Adjuster, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Box[] = {{&_swigt__p_p_Fl_Box, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Browser[] = {{&_swigt__p_p_Fl_Browser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Browser_[] = {{&_swigt__p_p_Fl_Browser_, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Button[] = {{&_swigt__p_p_Fl_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Chart[] = {{&_swigt__p_p_Fl_Chart, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Check_Browser[] = {{&_swigt__p_p_Fl_Check_Browser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Check_Button[] = {{&_swigt__p_p_Fl_Check_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Choice[] = {{&_swigt__p_p_Fl_Choice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Clock[] = {{&_swigt__p_p_Fl_Clock, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Clock_Output[] = {{&_swigt__p_p_Fl_Clock_Output, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Color_Chooser[] = {{&_swigt__p_p_Fl_Color_Chooser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Counter[] = {{&_swigt__p_p_Fl_Counter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Dial[] = {{&_swigt__p_p_Fl_Dial, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Double_Window[] = {{&_swigt__p_p_Fl_Double_Window, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_File_Browser[] = {{&_swigt__p_p_Fl_File_Browser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_File_Input[] = {{&_swigt__p_p_Fl_File_Input, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Fill_Dial[] = {{&_swigt__p_p_Fl_Fill_Dial, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Fill_Slider[] = {{&_swigt__p_p_Fl_Fill_Slider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Flex[] = {{&_swigt__p_p_Fl_Flex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Float_Input[] = {{&_swigt__p_p_Fl_Float_Input, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Gl_Window[] = {{&_swigt__p_p_Fl_Gl_Window, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Grid[] = {{&_swigt__p_p_Fl_Grid, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Group[] = {{&_swigt__p_p_Fl_Group, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Help_View[] = {{&_swigt__p_p_Fl_Help_View, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Hold_Browser[] = {{&_swigt__p_p_Fl_Hold_Browser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Hor_Fill_Slider[] = {{&_swigt__p_p_Fl_Hor_Fill_Slider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Hor_Nice_Slider[] = {{&_swigt__p_p_Fl_Hor_Nice_Slider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Hor_Slider[] = {{&_swigt__p_p_Fl_Hor_Slider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Hor_Value_Slider[] = {{&_swigt__p_p_Fl_Hor_Value_Slider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Input[] = {{&_swigt__p_p_Fl_Input, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Input_[] = {{&_swigt__p_p_Fl_Input_, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Input_Choice[] = {{&_swigt__p_p_Fl_Input_Choice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Int_Input[] = {{&_swigt__p_p_Fl_Int_Input, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Light_Button[] = {{&_swigt__p_p_Fl_Light_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Line_Dial[] = {{&_swigt__p_p_Fl_Line_Dial, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Menu_[] = {{&_swigt__p_p_Fl_Menu_, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Menu_Bar[] = {{&_swigt__p_p_Fl_Menu_Bar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Menu_Button[] = {{&_swigt__p_p_Fl_Menu_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Menu_Window[] = {{&_swigt__p_p_Fl_Menu_Window, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Multi_Browser[] = {{&_swigt__p_p_Fl_Multi_Browser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Multiline_Input[] = {{&_swigt__p_p_Fl_Multiline_Input, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Multiline_Output[] = {{&_swigt__p_p_Fl_Multiline_Output, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Nice_Slider[] = {{&_swigt__p_p_Fl_Nice_Slider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Output[] = {{&_swigt__p_p_Fl_Output, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Overlay_Window[] = {{&_swigt__p_p_Fl_Overlay_Window, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Pack[] = {{&_swigt__p_p_Fl_Pack, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Positioner[] = {{&_swigt__p_p_Fl_Positioner, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Progress[] = {{&_swigt__p_p_Fl_Progress, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Radio_Button[] = {{&_swigt__p_p_Fl_Radio_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Radio_Light_Button[] = {{&_swigt__p_p_Fl_Radio_Light_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Radio_Round_Button[] = {{&_swigt__p_p_Fl_Radio_Round_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Repeat_Button[] = {{&_swigt__p_p_Fl_Repeat_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Return_Button[] = {{&_swigt__p_p_Fl_Return_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Roller[] = {{&_swigt__p_p_Fl_Roller, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Round_Button[] = {{&_swigt__p_p_Fl_Round_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Round_Clock[] = {{&_swigt__p_p_Fl_Round_Clock, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Scheme_Choice[] = {{&_swigt__p_p_Fl_Scheme_Choice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Scroll[] = {{&_swigt__p_p_Fl_Scroll, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Scrollbar[] = {{&_swigt__p_p_Fl_Scrollbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Secret_Input[] = {{&_swigt__p_p_Fl_Secret_Input, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Select_Browser[] = {{&_swigt__p_p_Fl_Select_Browser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Shortcut_Button[] = {{&_swigt__p_p_Fl_Shortcut_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Simple_Counter[] = {{&_swigt__p_p_Fl_Simple_Counter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Single_Window[] = {{&_swigt__p_p_Fl_Single_Window, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Slider[] = {{&_swigt__p_p_Fl_Slider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Spinner[] = {{&_swigt__p_p_Fl_Spinner, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Sys_Menu_Bar[] = {{&_swigt__p_p_Fl_Sys_Menu_Bar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Table[] = {{&_swigt__p_p_Fl_Table, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Table_Row[] = {{&_swigt__p_p_Fl_Table_Row, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Tabs[] = {{&_swigt__p_p_Fl_Tabs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Terminal[] = {{&_swigt__p_p_Fl_Terminal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Text_Display[] = {{&_swigt__p_p_Fl_Text_Display, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Text_Editor[] = {{&_swigt__p_p_Fl_Text_Editor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Tile[] = {{&_swigt__p_p_Fl_Tile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Toggle_Button[] = {{&_swigt__p_p_Fl_Toggle_Button, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Tree[] = {{&_swigt__p_p_Fl_Tree, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Valuator[] = {{&_swigt__p_p_Fl_Valuator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Value_Input[] = {{&_swigt__p_p_Fl_Value_Input, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Value_Output[] = {{&_swigt__p_p_Fl_Value_Output, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Value_Slider[] = {{&_swigt__p_p_Fl_Value_Slider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Window[] = {{&_swigt__p_p_Fl_Window, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Wizard[] = {{&_swigt__p_p_Fl_Wizard, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Flcc_HueBox[] = {{&_swigt__p_p_Flcc_HueBox, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Flcc_ValueBox[] = {{&_swigt__p_p_Flcc_ValueBox, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Flcc_Value_Input[] = {{&_swigt__p_p_Flcc_Value_Input, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_ListSelect[] = {{&_swigt__p_p_ListSelect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Widget[] = {  {&_swigt__p_p_Fl_Widget, 0, 0, 0},  {&_swigt__p_p_Fl_Adjuster, _p_p_Fl_AdjusterTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Box, _p_p_Fl_BoxTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Browser, _p_p_Fl_BrowserTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Browser_, _p_p_Fl_Browser_To_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Button, _p_p_Fl_ButtonTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Chart, _p_p_Fl_ChartTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Check_Browser, _p_p_Fl_Check_BrowserTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Check_Button, _p_p_Fl_Check_ButtonTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Choice, _p_p_Fl_ChoiceTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Clock, _p_p_Fl_ClockTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Clock_Output, _p_p_Fl_Clock_OutputTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Color_Chooser, _p_p_Fl_Color_ChooserTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Counter, _p_p_Fl_CounterTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Dial, _p_p_Fl_DialTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Double_Window, _p_p_Fl_Double_WindowTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_File_Browser, _p_p_Fl_File_BrowserTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_File_Input, _p_p_Fl_File_InputTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Fill_Dial, _p_p_Fl_Fill_DialTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Fill_Slider, _p_p_Fl_Fill_SliderTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Flex, _p_p_Fl_FlexTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Float_Input, _p_p_Fl_Float_InputTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Gl_Window, _p_p_Fl_Gl_WindowTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Grid, _p_p_Fl_GridTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Group, _p_p_Fl_GroupTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Help_View, _p_p_Fl_Help_ViewTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Hold_Browser, _p_p_Fl_Hold_BrowserTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Hor_Fill_Slider, _p_p_Fl_Hor_Fill_SliderTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Hor_Nice_Slider, _p_p_Fl_Hor_Nice_SliderTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Hor_Slider, _p_p_Fl_Hor_SliderTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Hor_Value_Slider, _p_p_Fl_Hor_Value_SliderTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Input, _p_p_Fl_InputTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Input_, _p_p_Fl_Input_To_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Input_Choice, _p_p_Fl_Input_ChoiceTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Int_Input, _p_p_Fl_Int_InputTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Light_Button, _p_p_Fl_Light_ButtonTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Line_Dial, _p_p_Fl_Line_DialTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Menu_, _p_p_Fl_Menu_To_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Menu_Bar, _p_p_Fl_Menu_BarTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Menu_Button, _p_p_Fl_Menu_ButtonTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Menu_Window, _p_p_Fl_Menu_WindowTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Multi_Browser, _p_p_Fl_Multi_BrowserTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Multiline_Input, _p_p_Fl_Multiline_InputTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Multiline_Output, _p_p_Fl_Multiline_OutputTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Nice_Slider, _p_p_Fl_Nice_SliderTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Output, _p_p_Fl_OutputTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Overlay_Window, _p_p_Fl_Overlay_WindowTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Pack, _p_p_Fl_PackTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Positioner, _p_p_Fl_PositionerTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Progress, _p_p_Fl_ProgressTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Radio_Button, _p_p_Fl_Radio_ButtonTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Radio_Light_Button, _p_p_Fl_Radio_Light_ButtonTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Radio_Round_Button, _p_p_Fl_Radio_Round_ButtonTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Repeat_Button, _p_p_Fl_Repeat_ButtonTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Return_Button, _p_p_Fl_Return_ButtonTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Roller, _p_p_Fl_RollerTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Round_Button, _p_p_Fl_Round_ButtonTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Round_Clock, _p_p_Fl_Round_ClockTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Scheme_Choice, _p_p_Fl_Scheme_ChoiceTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Scroll, _p_p_Fl_ScrollTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Scrollbar, _p_p_Fl_ScrollbarTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Secret_Input, _p_p_Fl_Secret_InputTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Select_Browser, _p_p_Fl_Select_BrowserTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Shortcut_Button, _p_p_Fl_Shortcut_ButtonTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Simple_Counter, _p_p_Fl_Simple_CounterTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Single_Window, _p_p_Fl_Single_WindowTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Slider, _p_p_Fl_SliderTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Spinner, _p_p_Fl_SpinnerTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Sys_Menu_Bar, _p_p_Fl_Sys_Menu_BarTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Table, _p_p_Fl_TableTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Table_Row, _p_p_Fl_Table_RowTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Tabs, _p_p_Fl_TabsTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Terminal, _p_p_Fl_TerminalTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Text_Display, _p_p_Fl_Text_DisplayTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Text_Editor, _p_p_Fl_Text_EditorTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Tile, _p_p_Fl_TileTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Toggle_Button, _p_p_Fl_Toggle_ButtonTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Tree, _p_p_Fl_TreeTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Valuator, _p_p_Fl_ValuatorTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Value_Input, _p_p_Fl_Value_InputTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Value_Output, _p_p_Fl_Value_OutputTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Value_Slider, _p_p_Fl_Value_SliderTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Window, _p_p_Fl_WindowTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Wizard, _p_p_Fl_WizardTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Flcc_HueBox, _p_p_Flcc_HueBoxTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Flcc_ValueBox, _p_p_Flcc_ValueBoxTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Flcc_Value_Input, _p_p_Flcc_Value_InputTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_ListSelect, _p_p_ListSelectTo_p_p_Fl_Widget, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_p_char[] = {  {&_swigt__p_p_p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_p_dirent[] = {  {&_swigt__p_p_p_dirent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_void[] = {  {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Fl__TimeoutData_t[] = {  {&_swigt__p_std__vectorT_Fl__TimeoutData_t, 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[] = {  {&_swigt__p_unsigned_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 _swigc__p_window_menu_style_enum[] = {  {&_swigt__p_window_menu_style_enum, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_FILE,
  _swigc__p_FL_CHART_ENTRY,
  _swigc__p_Fl_Abort_Handler,
  _swigc__p_Fl_Adjuster,
  _swigc__p_Fl_Anim_GIF_Image,
  _swigc__p_Fl_Args_Handler,
  _swigc__p_Fl_Atclose_Handler,
  _swigc__p_Fl_Awake_Handler,
  _swigc__p_Fl_BMP_Image,
  _swigc__p_Fl_Bitmap,
  _swigc__p_Fl_Box,
  _swigc__p_Fl_Box_Draw_F,
  _swigc__p_Fl_Box_Draw_Focus_F,
  _swigc__p_Fl_Browser,
  _swigc__p_Fl_Browser_,
  _swigc__p_Fl_Button,
  _swigc__p_Fl_Callback_User_Data,
  _swigc__p_Fl_Chart,
  _swigc__p_Fl_Check_Browser,
  _swigc__p_Fl_Check_Button,
  _swigc__p_Fl_Choice,
  _swigc__p_Fl_Clipboard_Notify_Handler,
  _swigc__p_Fl_Clock,
  _swigc__p_Fl_Clock_Output,
  _swigc__p_Fl_Color_Chooser,
  _swigc__p_Fl_Copy_Surface,
  _swigc__p_Fl_Copy_Surface_Driver,
  _swigc__p_Fl_Counter,
  _swigc__p_Fl_Device_Plugin,
  _swigc__p_Fl_Dial,
  _swigc__p_Fl_Display_Device,
  _swigc__p_Fl_Double_Window,
  _swigc__p_Fl_EPS_File_Surface,
  _swigc__p_Fl_End,
  _swigc__p_Fl_File_Browser,
  _swigc__p_Fl_File_Chooser,
  _swigc__p_Fl_File_Icon,
  _swigc__p_Fl_File_Input,
  _swigc__p_Fl_Fill_Dial,
  _swigc__p_Fl_Fill_Slider,
  _swigc__p_Fl_Flex,
  _swigc__p_Fl_Float_Input,
  _swigc__p_Fl_GIF_Image,
  _swigc__p_Fl_Gl_Window,
  _swigc__p_Fl_Graphics_Driver,
  _swigc__p_Fl_Grid,
  _swigc__p_Fl_Grid__Cell,
  _swigc__p_Fl_Group,
  _swigc__p_Fl_Help_Dialog,
  _swigc__p_Fl_Help_View,
  _swigc__p_Fl_Hold_Browser,
  _swigc__p_Fl_Hor_Fill_Slider,
  _swigc__p_Fl_Hor_Nice_Slider,
  _swigc__p_Fl_Hor_Slider,
  _swigc__p_Fl_Hor_Value_Slider,
  _swigc__p_Fl_ICO_Image,
  _swigc__p_Fl_ICO_Image__IconDirEntry,
  _swigc__p_Fl_Idle_Handler,
  _swigc__p_Fl_Image,
  _swigc__p_Fl_Image_Surface,
  _swigc__p_Fl_Image_Surface_Driver,
  _swigc__p_Fl_Input,
  _swigc__p_Fl_Input_,
  _swigc__p_Fl_Input_Choice,
  _swigc__p_Fl_Int_Input,
  _swigc__p_Fl_JPEG_Image,
  _swigc__p_Fl_Label,
  _swigc__p_Fl_Label_Draw_F,
  _swigc__p_Fl_Label_Measure_F,
  _swigc__p_Fl_Light_Button,
  _swigc__p_Fl_Line_Dial,
  _swigc__p_Fl_Menu_,
  _swigc__p_Fl_Menu_Bar,
  _swigc__p_Fl_Menu_Button,
  _swigc__p_Fl_Menu_Item,
  _swigc__p_Fl_Menu_Window,
  _swigc__p_Fl_Multi_Browser,
  _swigc__p_Fl_Multi_Label,
  _swigc__p_Fl_Multiline_Input,
  _swigc__p_Fl_Multiline_Output,
  _swigc__p_Fl_Native_File_Chooser,
  _swigc__p_Fl_Native_File_Chooser_Driver,
  _swigc__p_Fl_Native_File_Chooser_FLTK_Driver,
  _swigc__p_Fl_Nice_Slider,
  _swigc__p_Fl_Offscreen,
  _swigc__p_Fl_Old_Idle_Handler,
  _swigc__p_Fl_Output,
  _swigc__p_Fl_Overlay_Window,
  _swigc__p_Fl_PDF_File_Surface,
  _swigc__p_Fl_PNG_Image,
  _swigc__p_Fl_PNM_Image,
  _swigc__p_Fl_Pack,
  _swigc__p_Fl_Paged_Device,
  _swigc__p_Fl_Pixmap,
  _swigc__p_Fl_Plugin,
  _swigc__p_Fl_Plugin_Manager,
  _swigc__p_Fl_Positioner,
  _swigc__p_Fl_PostScript_File_Device,
  _swigc__p_Fl_Preferences,
  _swigc__p_Fl_Preferences__ID,
  _swigc__p_Fl_Printer,
  _swigc__p_Fl_Progress,
  _swigc__p_Fl_RGB_Image,
  _swigc__p_Fl_Radio_Button,
  _swigc__p_Fl_Radio_Light_Button,
  _swigc__p_Fl_Radio_Round_Button,
  _swigc__p_Fl_Rect,
  _swigc__p_Fl_Region,
  _swigc__p_Fl_Repeat_Button,
  _swigc__p_Fl_Return_Button,
  _swigc__p_Fl_Roller,
  _swigc__p_Fl_Round_Button,
  _swigc__p_Fl_Round_Clock,
  _swigc__p_Fl_SVG_File_Surface,
  _swigc__p_Fl_SVG_Image,
  _swigc__p_Fl_Scheme_Choice,
  _swigc__p_Fl_Screen_Driver,
  _swigc__p_Fl_Scroll,
  _swigc__p_Fl_Scrollbar,
  _swigc__p_Fl_Secret_Input,
  _swigc__p_Fl_Select_Browser,
  _swigc__p_Fl_Shared_Image,
  _swigc__p_Fl_Shortcut_Button,
  _swigc__p_Fl_Simple_Counter,
  _swigc__p_Fl_Single_Window,
  _swigc__p_Fl_Slider,
  _swigc__p_Fl_Spinner,
  _swigc__p_Fl_Surface_Device,
  _swigc__p_Fl_Sys_Menu_Bar,
  _swigc__p_Fl_System_Driver,
  _swigc__p_Fl_Table,
  _swigc__p_Fl_Table_Row,
  _swigc__p_Fl_Tabs,
  _swigc__p_Fl_Terminal,
  _swigc__p_Fl_Text_Buffer,
  _swigc__p_Fl_Text_Display,
  _swigc__p_Fl_Text_Display__Style_Table_Entry,
  _swigc__p_Fl_Text_Editor,
  _swigc__p_Fl_Text_Editor__Key_Binding,
  _swigc__p_Fl_Text_Selection,
  _swigc__p_Fl_Tile,
  _swigc__p_Fl_Tiled_Image,
  _swigc__p_Fl_Timeout_Handler,
  _swigc__p_Fl_Timestamp,
  _swigc__p_Fl_Toggle_Button,
  _swigc__p_Fl_Tooltip,
  _swigc__p_Fl_Tree,
  _swigc__p_Fl_Tree_Item,
  _swigc__p_Fl_Tree_Item_Array,
  _swigc__p_Fl_Tree_Prefs,
  _swigc__p_Fl_Valuator,
  _swigc__p_Fl_Value_Input,
  _swigc__p_Fl_Value_Output,
  _swigc__p_Fl_Value_Slider,
  _swigc__p_Fl_Vk_Window,
  _swigc__p_Fl_Widget,
  _swigc__p_Fl_Widget_Surface,
  _swigc__p_Fl_Window,
  _swigc__p_Fl_Wizard,
  _swigc__p_Fl_X,
  _swigc__p_Fl_XBM_Image,
  _swigc__p_Fl_XPM_Image,
  _swigc__p_Fl__TimeoutData,
  _swigc__p_Flcc_HueBox,
  _swigc__p_Flcc_ValueBox,
  _swigc__p_Flcc_Value_Input,
  _swigc__p_GLContext,
  _swigc__p_ListSelect,
  _swigc__p_Scale_Type,
  _swigc__p_Style_Table_Entry,
  _swigc__p_Tick_Position,
  _swigc__p_Window,
  _swigc__p_char,
  _swigc__p_double,
  _swigc__p_f_int_int_int_int_p_q_const__char_p_void__void,
  _swigc__p_f_int_int_p_void__void,
  _swigc__p_f_int_p_Fl_Text_Editor__int,
  _swigc__p_f_p_FILE__int,
  _swigc__p_f_p_Fl_File_Chooser_p_void__void,
  _swigc__p_f_p_Fl_Tree_Item_p_void__void,
  _swigc__p_f_p_Fl_Widget__void,
  _swigc__p_f_p_Fl_Widget_long__void,
  _swigc__p_f_p_Fl_Widget_p_q_const__char__p_char,
  _swigc__p_f_p_Fl_Widget_p_void__void,
  _swigc__p_f_p_q_const__char__void,
  _swigc__p_f_p_q_const__char_int_int_int__void,
  _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_Anim_GIF_Image,
  _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_BMP_Image,
  _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_Bitmap,
  _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_GIF_Image,
  _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_ICO_Image,
  _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_Image,
  _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_JPEG_Image,
  _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_PNG_Image,
  _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_PNM_Image,
  _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_Pixmap,
  _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_RGB_Image,
  _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_SVG_Image,
  _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_Shared_Image,
  _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_Tiled_Image,
  _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_XBM_Image,
  _swigc__p_f_p_q_const__char_p_uchar_int__p_Fl_XPM_Image,
  _swigc__p_f_p_void_int_int_int_int__void,
  _swigc__p_f_unsigned_int__void,
  _swigc__p_f_unsigned_int_unsigned_int_int_int__unsigned_int,
  _swigc__p_fl_uintptr_t,
  _swigc__p_float,
  _swigc__p_int,
  _swigc__p_p_Fl_Adjuster,
  _swigc__p_p_Fl_BMP_Image,
  _swigc__p_p_Fl_Box,
  _swigc__p_p_Fl_Browser,
  _swigc__p_p_Fl_Browser_,
  _swigc__p_p_Fl_Button,
  _swigc__p_p_Fl_Chart,
  _swigc__p_p_Fl_Check_Browser,
  _swigc__p_p_Fl_Check_Button,
  _swigc__p_p_Fl_Choice,
  _swigc__p_p_Fl_Clock,
  _swigc__p_p_Fl_Clock_Output,
  _swigc__p_p_Fl_Color_Chooser,
  _swigc__p_p_Fl_Counter,
  _swigc__p_p_Fl_Dial,
  _swigc__p_p_Fl_Double_Window,
  _swigc__p_p_Fl_File_Browser,
  _swigc__p_p_Fl_File_Input,
  _swigc__p_p_Fl_Fill_Dial,
  _swigc__p_p_Fl_Fill_Slider,
  _swigc__p_p_Fl_Flex,
  _swigc__p_p_Fl_Float_Input,
  _swigc__p_p_Fl_Gl_Window,
  _swigc__p_p_Fl_Grid,
  _swigc__p_p_Fl_Group,
  _swigc__p_p_Fl_Help_View,
  _swigc__p_p_Fl_Hold_Browser,
  _swigc__p_p_Fl_Hor_Fill_Slider,
  _swigc__p_p_Fl_Hor_Nice_Slider,
  _swigc__p_p_Fl_Hor_Slider,
  _swigc__p_p_Fl_Hor_Value_Slider,
  _swigc__p_p_Fl_ICO_Image,
  _swigc__p_p_Fl_Input,
  _swigc__p_p_Fl_Input_,
  _swigc__p_p_Fl_Input_Choice,
  _swigc__p_p_Fl_Int_Input,
  _swigc__p_p_Fl_JPEG_Image,
  _swigc__p_p_Fl_Light_Button,
  _swigc__p_p_Fl_Line_Dial,
  _swigc__p_p_Fl_Menu_,
  _swigc__p_p_Fl_Menu_Bar,
  _swigc__p_p_Fl_Menu_Button,
  _swigc__p_p_Fl_Menu_Window,
  _swigc__p_p_Fl_Multi_Browser,
  _swigc__p_p_Fl_Multiline_Input,
  _swigc__p_p_Fl_Multiline_Output,
  _swigc__p_p_Fl_Nice_Slider,
  _swigc__p_p_Fl_Output,
  _swigc__p_p_Fl_Overlay_Window,
  _swigc__p_p_Fl_PNG_Image,
  _swigc__p_p_Fl_PNM_Image,
  _swigc__p_p_Fl_Pack,
  _swigc__p_p_Fl_Positioner,
  _swigc__p_p_Fl_Progress,
  _swigc__p_p_Fl_RGB_Image,
  _swigc__p_p_Fl_Radio_Button,
  _swigc__p_p_Fl_Radio_Light_Button,
  _swigc__p_p_Fl_Radio_Round_Button,
  _swigc__p_p_Fl_Repeat_Button,
  _swigc__p_p_Fl_Return_Button,
  _swigc__p_p_Fl_Roller,
  _swigc__p_p_Fl_Round_Button,
  _swigc__p_p_Fl_Round_Clock,
  _swigc__p_p_Fl_SVG_Image,
  _swigc__p_p_Fl_Scheme_Choice,
  _swigc__p_p_Fl_Scroll,
  _swigc__p_p_Fl_Scrollbar,
  _swigc__p_p_Fl_Secret_Input,
  _swigc__p_p_Fl_Select_Browser,
  _swigc__p_p_Fl_Shared_Image,
  _swigc__p_p_Fl_Shortcut_Button,
  _swigc__p_p_Fl_Simple_Counter,
  _swigc__p_p_Fl_Single_Window,
  _swigc__p_p_Fl_Slider,
  _swigc__p_p_Fl_Spinner,
  _swigc__p_p_Fl_Sys_Menu_Bar,
  _swigc__p_p_Fl_Table,
  _swigc__p_p_Fl_Table_Row,
  _swigc__p_p_Fl_Tabs,
  _swigc__p_p_Fl_Terminal,
  _swigc__p_p_Fl_Text_Display,
  _swigc__p_p_Fl_Text_Editor,
  _swigc__p_p_Fl_Tile,
  _swigc__p_p_Fl_Toggle_Button,
  _swigc__p_p_Fl_Tree,
  _swigc__p_p_Fl_Valuator,
  _swigc__p_p_Fl_Value_Input,
  _swigc__p_p_Fl_Value_Output,
  _swigc__p_p_Fl_Value_Slider,
  _swigc__p_p_Fl_Widget,
  _swigc__p_p_Fl_Window,
  _swigc__p_p_Fl_Wizard,
  _swigc__p_p_Flcc_HueBox,
  _swigc__p_p_Flcc_ValueBox,
  _swigc__p_p_Flcc_Value_Input,
  _swigc__p_p_ListSelect,
  _swigc__p_p_char,
  _swigc__p_p_p_char,
  _swigc__p_p_p_dirent,
  _swigc__p_p_void,
  _swigc__p_short,
  _swigc__p_std__vectorT_Fl__TimeoutData_t,
  _swigc__p_unsigned_char,
  _swigc__p_unsigned_int,
  _swigc__p_unsigned_long,
  _swigc__p_unsigned_short,
  _swigc__p_void,
  _swigc__p_wchar_t,
  _swigc__p_window_menu_style_enum,
};


/* -------- 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 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 linked list. 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. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it
 * adding the casts to the list. The one last 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 linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#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

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 *ret;
    swig_cast_info *cast;
    
#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 = swig_module.cast_initial[i];
    while (cast->type) {
      /* Don't need to add information already in the list */
      ret = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
      }
      if (ret) {
        if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
          cast->type = ret;
          ret = 0;
        } else {
          /* Check for casting already in the list */
          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
          if (!ocast) ret = 0;
        }
      }
      
      if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        if (type->cast) {
          type->cast->prev = cast;
          cast->next = type->cast;
        }
        type->cast = 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;
  swig_cast_info *equiv;
  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) {
      equiv = swig_module.types[i]->cast;
      while (equiv) {
        if (!equiv->converter) {
          if (equiv->type && !equiv->type->clientdata)
          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
        }
        equiv = equiv->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
 * -----------------------------------------------------------------------------*/

#ifdef __cplusplus
extern "C"
#endif

SWIGEXPORT 
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
  PyObject *m, *d, *md, *globals;
  
#if PY_VERSION_HEX >= 0x03000000
  static struct PyModuleDef SWIG_module = {
    PyModuleDef_HEAD_INIT,
    SWIG_name,
    NULL,
    -1,
    SwigMethods,
    NULL,
    NULL,
    NULL,
    NULL
  };
#endif
  
#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();
  assert(metatype);
#endif
  
  (void)globals;
  
  /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
  SWIG_This();
  SWIG_Python_TypeCache();
  SwigPyPacked_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);
  
#if PY_VERSION_HEX >= 0x03000000
  m = PyModule_Create(&SWIG_module);
#else
  m = Py_InitModule(SWIG_name, SwigMethods);
#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.");
# if PY_VERSION_HEX >= 0x03000000
    return NULL;
# else
    return;
# endif
  }
  
  /* 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);
  
  
  // Patch 1767434, interactive pyFltk
  if (PyOS_InputHook==NULL) 
  PyOS_InputHook = _run_loop_interactive;
  else 
  PyErr_Warn(PyExc_RuntimeWarning, "PyOS_InputHook is not available for interactive use of pyFltk");
  // End of patch 1767434, interactive pyFltk
  
  // 
  
  SWIG_Python_SetConstant(d, "FL_NO_EVENT",SWIG_From_int((int)(FL_NO_EVENT)));
  SWIG_Python_SetConstant(d, "FL_PUSH",SWIG_From_int((int)(FL_PUSH)));
  SWIG_Python_SetConstant(d, "FL_RELEASE",SWIG_From_int((int)(FL_RELEASE)));
  SWIG_Python_SetConstant(d, "FL_ENTER",SWIG_From_int((int)(FL_ENTER)));
  SWIG_Python_SetConstant(d, "FL_LEAVE",SWIG_From_int((int)(FL_LEAVE)));
  SWIG_Python_SetConstant(d, "FL_DRAG",SWIG_From_int((int)(FL_DRAG)));
  SWIG_Python_SetConstant(d, "FL_FOCUS",SWIG_From_int((int)(FL_FOCUS)));
  SWIG_Python_SetConstant(d, "FL_UNFOCUS",SWIG_From_int((int)(FL_UNFOCUS)));
  SWIG_Python_SetConstant(d, "FL_KEYDOWN",SWIG_From_int((int)(FL_KEYDOWN)));
  SWIG_Python_SetConstant(d, "FL_KEYBOARD",SWIG_From_int((int)(FL_KEYBOARD)));
  SWIG_Python_SetConstant(d, "FL_KEYUP",SWIG_From_int((int)(FL_KEYUP)));
  SWIG_Python_SetConstant(d, "FL_CLOSE",SWIG_From_int((int)(FL_CLOSE)));
  SWIG_Python_SetConstant(d, "FL_MOVE",SWIG_From_int((int)(FL_MOVE)));
  SWIG_Python_SetConstant(d, "FL_SHORTCUT",SWIG_From_int((int)(FL_SHORTCUT)));
  SWIG_Python_SetConstant(d, "FL_DEACTIVATE",SWIG_From_int((int)(FL_DEACTIVATE)));
  SWIG_Python_SetConstant(d, "FL_ACTIVATE",SWIG_From_int((int)(FL_ACTIVATE)));
  SWIG_Python_SetConstant(d, "FL_HIDE",SWIG_From_int((int)(FL_HIDE)));
  SWIG_Python_SetConstant(d, "FL_SHOW",SWIG_From_int((int)(FL_SHOW)));
  SWIG_Python_SetConstant(d, "FL_PASTE",SWIG_From_int((int)(FL_PASTE)));
  SWIG_Python_SetConstant(d, "FL_SELECTIONCLEAR",SWIG_From_int((int)(FL_SELECTIONCLEAR)));
  SWIG_Python_SetConstant(d, "FL_MOUSEWHEEL",SWIG_From_int((int)(FL_MOUSEWHEEL)));
  SWIG_Python_SetConstant(d, "FL_DND_ENTER",SWIG_From_int((int)(FL_DND_ENTER)));
  SWIG_Python_SetConstant(d, "FL_DND_DRAG",SWIG_From_int((int)(FL_DND_DRAG)));
  SWIG_Python_SetConstant(d, "FL_DND_LEAVE",SWIG_From_int((int)(FL_DND_LEAVE)));
  SWIG_Python_SetConstant(d, "FL_DND_RELEASE",SWIG_From_int((int)(FL_DND_RELEASE)));
  SWIG_Python_SetConstant(d, "FL_SCREEN_CONFIGURATION_CHANGED",SWIG_From_int((int)(FL_SCREEN_CONFIGURATION_CHANGED)));
  SWIG_Python_SetConstant(d, "FL_FULLSCREEN",SWIG_From_int((int)(FL_FULLSCREEN)));
  SWIG_Python_SetConstant(d, "FL_ZOOM_GESTURE",SWIG_From_int((int)(FL_ZOOM_GESTURE)));
  SWIG_Python_SetConstant(d, "FL_ZOOM_EVENT",SWIG_From_int((int)(FL_ZOOM_EVENT)));
  SWIG_Python_SetConstant(d, "FL_BEFORE_TOOLTIP",SWIG_From_int((int)(FL_BEFORE_TOOLTIP)));
  SWIG_Python_SetConstant(d, "FL_BEFORE_MENU",SWIG_From_int((int)(FL_BEFORE_MENU)));
  SWIG_Python_SetConstant(d, "FL_WHEN_NEVER",SWIG_From_int((int)(FL_WHEN_NEVER)));
  SWIG_Python_SetConstant(d, "FL_WHEN_CHANGED",SWIG_From_int((int)(FL_WHEN_CHANGED)));
  SWIG_Python_SetConstant(d, "FL_WHEN_NOT_CHANGED",SWIG_From_int((int)(FL_WHEN_NOT_CHANGED)));
  SWIG_Python_SetConstant(d, "FL_WHEN_RELEASE",SWIG_From_int((int)(FL_WHEN_RELEASE)));
  SWIG_Python_SetConstant(d, "FL_WHEN_RELEASE_ALWAYS",SWIG_From_int((int)(FL_WHEN_RELEASE_ALWAYS)));
  SWIG_Python_SetConstant(d, "FL_WHEN_ENTER_KEY",SWIG_From_int((int)(FL_WHEN_ENTER_KEY)));
  SWIG_Python_SetConstant(d, "FL_WHEN_ENTER_KEY_ALWAYS",SWIG_From_int((int)(FL_WHEN_ENTER_KEY_ALWAYS)));
  SWIG_Python_SetConstant(d, "FL_WHEN_ENTER_KEY_CHANGED",SWIG_From_int((int)(FL_WHEN_ENTER_KEY_CHANGED)));
  SWIG_Python_SetConstant(d, "FL_WHEN_CLOSED",SWIG_From_int((int)(FL_WHEN_CLOSED)));
  SWIG_Python_SetConstant(d, "FL_REASON_UNKNOWN",SWIG_From_int((int)(FL_REASON_UNKNOWN)));
  SWIG_Python_SetConstant(d, "FL_REASON_SELECTED",SWIG_From_int((int)(FL_REASON_SELECTED)));
  SWIG_Python_SetConstant(d, "FL_REASON_DESELECTED",SWIG_From_int((int)(FL_REASON_DESELECTED)));
  SWIG_Python_SetConstant(d, "FL_REASON_RESELECTED",SWIG_From_int((int)(FL_REASON_RESELECTED)));
  SWIG_Python_SetConstant(d, "FL_REASON_OPENED",SWIG_From_int((int)(FL_REASON_OPENED)));
  SWIG_Python_SetConstant(d, "FL_REASON_CLOSED",SWIG_From_int((int)(FL_REASON_CLOSED)));
  SWIG_Python_SetConstant(d, "FL_REASON_DRAGGED",SWIG_From_int((int)(FL_REASON_DRAGGED)));
  SWIG_Python_SetConstant(d, "FL_REASON_CANCELLED",SWIG_From_int((int)(FL_REASON_CANCELLED)));
  SWIG_Python_SetConstant(d, "FL_REASON_CHANGED",SWIG_From_int((int)(FL_REASON_CHANGED)));
  SWIG_Python_SetConstant(d, "FL_REASON_GOT_FOCUS",SWIG_From_int((int)(FL_REASON_GOT_FOCUS)));
  SWIG_Python_SetConstant(d, "FL_REASON_LOST_FOCUS",SWIG_From_int((int)(FL_REASON_LOST_FOCUS)));
  SWIG_Python_SetConstant(d, "FL_REASON_RELEASED",SWIG_From_int((int)(FL_REASON_RELEASED)));
  SWIG_Python_SetConstant(d, "FL_REASON_ENTER_KEY",SWIG_From_int((int)(FL_REASON_ENTER_KEY)));
  SWIG_Python_SetConstant(d, "FL_REASON_USER",SWIG_From_int((int)(FL_REASON_USER)));
  SWIG_Python_SetConstant(d, "FL_Button",SWIG_From_int((int)(0xfee8)));
  SWIG_Python_SetConstant(d, "FL_BackSpace",SWIG_From_int((int)(0xff08)));
  SWIG_Python_SetConstant(d, "FL_Tab",SWIG_From_int((int)(0xff09)));
  SWIG_Python_SetConstant(d, "FL_Iso_Key",SWIG_From_int((int)(0xff0c)));
  SWIG_Python_SetConstant(d, "FL_Enter",SWIG_From_int((int)(0xff0d)));
  SWIG_Python_SetConstant(d, "FL_Pause",SWIG_From_int((int)(0xff13)));
  SWIG_Python_SetConstant(d, "FL_Scroll_Lock",SWIG_From_int((int)(0xff14)));
  SWIG_Python_SetConstant(d, "FL_Escape",SWIG_From_int((int)(0xff1b)));
  SWIG_Python_SetConstant(d, "FL_Kana",SWIG_From_int((int)(0xff2e)));
  SWIG_Python_SetConstant(d, "FL_Eisu",SWIG_From_int((int)(0xff2f)));
  SWIG_Python_SetConstant(d, "FL_Yen",SWIG_From_int((int)(0xff30)));
  SWIG_Python_SetConstant(d, "FL_JIS_Underscore",SWIG_From_int((int)(0xff31)));
  SWIG_Python_SetConstant(d, "FL_Home",SWIG_From_int((int)(0xff50)));
  SWIG_Python_SetConstant(d, "FL_Left",SWIG_From_int((int)(0xff51)));
  SWIG_Python_SetConstant(d, "FL_Up",SWIG_From_int((int)(0xff52)));
  SWIG_Python_SetConstant(d, "FL_Right",SWIG_From_int((int)(0xff53)));
  SWIG_Python_SetConstant(d, "FL_Down",SWIG_From_int((int)(0xff54)));
  SWIG_Python_SetConstant(d, "FL_Page_Up",SWIG_From_int((int)(0xff55)));
  SWIG_Python_SetConstant(d, "FL_Page_Down",SWIG_From_int((int)(0xff56)));
  SWIG_Python_SetConstant(d, "FL_End",SWIG_From_int((int)(0xff57)));
  SWIG_Python_SetConstant(d, "FL_Print",SWIG_From_int((int)(0xff61)));
  SWIG_Python_SetConstant(d, "FL_Insert",SWIG_From_int((int)(0xff63)));
  SWIG_Python_SetConstant(d, "FL_Menu",SWIG_From_int((int)(0xff67)));
  SWIG_Python_SetConstant(d, "FL_Help",SWIG_From_int((int)(0xff68)));
  SWIG_Python_SetConstant(d, "FL_Num_Lock",SWIG_From_int((int)(0xff7f)));
  SWIG_Python_SetConstant(d, "FL_KP",SWIG_From_int((int)(0xff80)));
  SWIG_Python_SetConstant(d, "FL_KP_Enter",SWIG_From_int((int)(0xff8d)));
  SWIG_Python_SetConstant(d, "FL_KP_Last",SWIG_From_int((int)(0xffbd)));
  SWIG_Python_SetConstant(d, "FL_F",SWIG_From_int((int)(0xffbd)));
  SWIG_Python_SetConstant(d, "FL_F_Last",SWIG_From_int((int)(0xffe0)));
  SWIG_Python_SetConstant(d, "FL_Shift_L",SWIG_From_int((int)(0xffe1)));
  SWIG_Python_SetConstant(d, "FL_Shift_R",SWIG_From_int((int)(0xffe2)));
  SWIG_Python_SetConstant(d, "FL_Control_L",SWIG_From_int((int)(0xffe3)));
  SWIG_Python_SetConstant(d, "FL_Control_R",SWIG_From_int((int)(0xffe4)));
  SWIG_Python_SetConstant(d, "FL_Caps_Lock",SWIG_From_int((int)(0xffe5)));
  SWIG_Python_SetConstant(d, "FL_Meta_L",SWIG_From_int((int)(0xffe7)));
  SWIG_Python_SetConstant(d, "FL_Meta_R",SWIG_From_int((int)(0xffe8)));
  SWIG_Python_SetConstant(d, "FL_Alt_L",SWIG_From_int((int)(0xffe9)));
  SWIG_Python_SetConstant(d, "FL_Alt_R",SWIG_From_int((int)(0xffea)));
  SWIG_Python_SetConstant(d, "FL_Delete",SWIG_From_int((int)(0xffff)));
  SWIG_Python_SetConstant(d, "FL_Alt_Gr",SWIG_From_int((int)(0xfe03)));
  SWIG_Python_SetConstant(d, "FL_Volume_Down",SWIG_From_int((int)(0xEF11)));
  SWIG_Python_SetConstant(d, "FL_Volume_Mute",SWIG_From_int((int)(0xEF12)));
  SWIG_Python_SetConstant(d, "FL_Volume_Up",SWIG_From_int((int)(0xEF13)));
  SWIG_Python_SetConstant(d, "FL_Media_Play",SWIG_From_int((int)(0xEF14)));
  SWIG_Python_SetConstant(d, "FL_Media_Stop",SWIG_From_int((int)(0xEF15)));
  SWIG_Python_SetConstant(d, "FL_Media_Prev",SWIG_From_int((int)(0xEF16)));
  SWIG_Python_SetConstant(d, "FL_Media_Next",SWIG_From_int((int)(0xEF17)));
  SWIG_Python_SetConstant(d, "FL_Home_Page",SWIG_From_int((int)(0xEF18)));
  SWIG_Python_SetConstant(d, "FL_Mail",SWIG_From_int((int)(0xEF19)));
  SWIG_Python_SetConstant(d, "FL_Search",SWIG_From_int((int)(0xEF1B)));
  SWIG_Python_SetConstant(d, "FL_Back",SWIG_From_int((int)(0xEF26)));
  SWIG_Python_SetConstant(d, "FL_Forward",SWIG_From_int((int)(0xEF27)));
  SWIG_Python_SetConstant(d, "FL_Stop",SWIG_From_int((int)(0xEF28)));
  SWIG_Python_SetConstant(d, "FL_Refresh",SWIG_From_int((int)(0xEF29)));
  SWIG_Python_SetConstant(d, "FL_Sleep",SWIG_From_int((int)(0xEF2F)));
  SWIG_Python_SetConstant(d, "FL_Favorites",SWIG_From_int((int)(0xEF30)));
  SWIG_Python_SetConstant(d, "FL_LEFT_MOUSE",SWIG_From_int((int)(1)));
  SWIG_Python_SetConstant(d, "FL_MIDDLE_MOUSE",SWIG_From_int((int)(2)));
  SWIG_Python_SetConstant(d, "FL_RIGHT_MOUSE",SWIG_From_int((int)(3)));
  SWIG_Python_SetConstant(d, "FL_BACK_MOUSE",SWIG_From_int((int)(4)));
  SWIG_Python_SetConstant(d, "FL_FORWARD_MOUSE",SWIG_From_int((int)(5)));
  SWIG_Python_SetConstant(d, "FL_SHIFT",SWIG_From_int((int)(0x00010000)));
  SWIG_Python_SetConstant(d, "FL_CAPS_LOCK",SWIG_From_int((int)(0x00020000)));
  SWIG_Python_SetConstant(d, "FL_CTRL",SWIG_From_int((int)(0x00040000)));
  SWIG_Python_SetConstant(d, "FL_ALT",SWIG_From_int((int)(0x00080000)));
  SWIG_Python_SetConstant(d, "FL_NUM_LOCK",SWIG_From_int((int)(0x00100000)));
  SWIG_Python_SetConstant(d, "FL_META",SWIG_From_int((int)(0x00400000)));
  SWIG_Python_SetConstant(d, "FL_SCROLL_LOCK",SWIG_From_int((int)(0x00800000)));
  SWIG_Python_SetConstant(d, "FL_BUTTON1",SWIG_From_int((int)(0x01000000)));
  SWIG_Python_SetConstant(d, "FL_BUTTON2",SWIG_From_int((int)(0x02000000)));
  SWIG_Python_SetConstant(d, "FL_BUTTON3",SWIG_From_int((int)(0x04000000)));
  SWIG_Python_SetConstant(d, "FL_BUTTON4",SWIG_From_int((int)(0x08000000)));
  SWIG_Python_SetConstant(d, "FL_BUTTON5",SWIG_From_int((int)(0x10000000)));
  SWIG_Python_SetConstant(d, "FL_BUTTONS",SWIG_From_int((int)(0x1f000000)));
  SWIG_Python_SetConstant(d, "FL_KEY_MASK",SWIG_From_int((int)(0x0000ffff)));
  SWIG_Python_SetConstant(d, "FL_NO_BOX",SWIG_From_int((int)(FL_NO_BOX)));
  SWIG_Python_SetConstant(d, "FL_FLAT_BOX",SWIG_From_int((int)(FL_FLAT_BOX)));
  SWIG_Python_SetConstant(d, "FL_UP_BOX",SWIG_From_int((int)(FL_UP_BOX)));
  SWIG_Python_SetConstant(d, "FL_DOWN_BOX",SWIG_From_int((int)(FL_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "FL_UP_FRAME",SWIG_From_int((int)(FL_UP_FRAME)));
  SWIG_Python_SetConstant(d, "FL_DOWN_FRAME",SWIG_From_int((int)(FL_DOWN_FRAME)));
  SWIG_Python_SetConstant(d, "FL_THIN_UP_BOX",SWIG_From_int((int)(FL_THIN_UP_BOX)));
  SWIG_Python_SetConstant(d, "FL_THIN_DOWN_BOX",SWIG_From_int((int)(FL_THIN_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "FL_THIN_UP_FRAME",SWIG_From_int((int)(FL_THIN_UP_FRAME)));
  SWIG_Python_SetConstant(d, "FL_THIN_DOWN_FRAME",SWIG_From_int((int)(FL_THIN_DOWN_FRAME)));
  SWIG_Python_SetConstant(d, "FL_ENGRAVED_BOX",SWIG_From_int((int)(FL_ENGRAVED_BOX)));
  SWIG_Python_SetConstant(d, "FL_EMBOSSED_BOX",SWIG_From_int((int)(FL_EMBOSSED_BOX)));
  SWIG_Python_SetConstant(d, "FL_ENGRAVED_FRAME",SWIG_From_int((int)(FL_ENGRAVED_FRAME)));
  SWIG_Python_SetConstant(d, "FL_EMBOSSED_FRAME",SWIG_From_int((int)(FL_EMBOSSED_FRAME)));
  SWIG_Python_SetConstant(d, "FL_BORDER_BOX",SWIG_From_int((int)(FL_BORDER_BOX)));
  SWIG_Python_SetConstant(d, "_FL_SHADOW_BOX",SWIG_From_int((int)(_FL_SHADOW_BOX)));
  SWIG_Python_SetConstant(d, "FL_BORDER_FRAME",SWIG_From_int((int)(FL_BORDER_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_SHADOW_FRAME",SWIG_From_int((int)(_FL_SHADOW_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_ROUNDED_BOX",SWIG_From_int((int)(_FL_ROUNDED_BOX)));
  SWIG_Python_SetConstant(d, "_FL_RSHADOW_BOX",SWIG_From_int((int)(_FL_RSHADOW_BOX)));
  SWIG_Python_SetConstant(d, "_FL_ROUNDED_FRAME",SWIG_From_int((int)(_FL_ROUNDED_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_RFLAT_BOX",SWIG_From_int((int)(_FL_RFLAT_BOX)));
  SWIG_Python_SetConstant(d, "_FL_ROUND_UP_BOX",SWIG_From_int((int)(_FL_ROUND_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_ROUND_DOWN_BOX",SWIG_From_int((int)(_FL_ROUND_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_DIAMOND_UP_BOX",SWIG_From_int((int)(_FL_DIAMOND_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_DIAMOND_DOWN_BOX",SWIG_From_int((int)(_FL_DIAMOND_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_OVAL_BOX",SWIG_From_int((int)(_FL_OVAL_BOX)));
  SWIG_Python_SetConstant(d, "_FL_OSHADOW_BOX",SWIG_From_int((int)(_FL_OSHADOW_BOX)));
  SWIG_Python_SetConstant(d, "_FL_OVAL_FRAME",SWIG_From_int((int)(_FL_OVAL_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_OFLAT_BOX",SWIG_From_int((int)(_FL_OFLAT_BOX)));
  SWIG_Python_SetConstant(d, "_FL_PLASTIC_UP_BOX",SWIG_From_int((int)(_FL_PLASTIC_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_PLASTIC_DOWN_BOX",SWIG_From_int((int)(_FL_PLASTIC_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_PLASTIC_UP_FRAME",SWIG_From_int((int)(_FL_PLASTIC_UP_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_PLASTIC_DOWN_FRAME",SWIG_From_int((int)(_FL_PLASTIC_DOWN_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_PLASTIC_THIN_UP_BOX",SWIG_From_int((int)(_FL_PLASTIC_THIN_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_PLASTIC_THIN_DOWN_BOX",SWIG_From_int((int)(_FL_PLASTIC_THIN_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_PLASTIC_ROUND_UP_BOX",SWIG_From_int((int)(_FL_PLASTIC_ROUND_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_PLASTIC_ROUND_DOWN_BOX",SWIG_From_int((int)(_FL_PLASTIC_ROUND_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GTK_UP_BOX",SWIG_From_int((int)(_FL_GTK_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GTK_DOWN_BOX",SWIG_From_int((int)(_FL_GTK_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GTK_UP_FRAME",SWIG_From_int((int)(_FL_GTK_UP_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_GTK_DOWN_FRAME",SWIG_From_int((int)(_FL_GTK_DOWN_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_GTK_THIN_UP_BOX",SWIG_From_int((int)(_FL_GTK_THIN_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GTK_THIN_DOWN_BOX",SWIG_From_int((int)(_FL_GTK_THIN_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GTK_THIN_UP_FRAME",SWIG_From_int((int)(_FL_GTK_THIN_UP_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_GTK_THIN_DOWN_FRAME",SWIG_From_int((int)(_FL_GTK_THIN_DOWN_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_GTK_ROUND_UP_BOX",SWIG_From_int((int)(_FL_GTK_ROUND_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GTK_ROUND_DOWN_BOX",SWIG_From_int((int)(_FL_GTK_ROUND_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GLEAM_UP_BOX",SWIG_From_int((int)(_FL_GLEAM_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GLEAM_DOWN_BOX",SWIG_From_int((int)(_FL_GLEAM_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GLEAM_UP_FRAME",SWIG_From_int((int)(_FL_GLEAM_UP_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_GLEAM_DOWN_FRAME",SWIG_From_int((int)(_FL_GLEAM_DOWN_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_GLEAM_THIN_UP_BOX",SWIG_From_int((int)(_FL_GLEAM_THIN_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GLEAM_THIN_DOWN_BOX",SWIG_From_int((int)(_FL_GLEAM_THIN_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GLEAM_ROUND_UP_BOX",SWIG_From_int((int)(_FL_GLEAM_ROUND_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GLEAM_ROUND_DOWN_BOX",SWIG_From_int((int)(_FL_GLEAM_ROUND_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_OXY_UP_BOX",SWIG_From_int((int)(_FL_OXY_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_OXY_DOWN_BOX",SWIG_From_int((int)(_FL_OXY_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_OXY_UP_FRAME",SWIG_From_int((int)(_FL_OXY_UP_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_OXY_DOWN_FRAME",SWIG_From_int((int)(_FL_OXY_DOWN_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_OXY_THIN_UP_BOX",SWIG_From_int((int)(_FL_OXY_THIN_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_OXY_THIN_DOWN_BOX",SWIG_From_int((int)(_FL_OXY_THIN_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_OXY_THIN_UP_FRAME",SWIG_From_int((int)(_FL_OXY_THIN_UP_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_OXY_THIN_DOWN_FRAME",SWIG_From_int((int)(_FL_OXY_THIN_DOWN_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_OXY_ROUND_UP_BOX",SWIG_From_int((int)(_FL_OXY_ROUND_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_OXY_ROUND_DOWN_BOX",SWIG_From_int((int)(_FL_OXY_ROUND_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_OXY_BUTTON_UP_BOX",SWIG_From_int((int)(_FL_OXY_BUTTON_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_OXY_BUTTON_DOWN_BOX",SWIG_From_int((int)(_FL_OXY_BUTTON_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "FL_FREE_BOXTYPE",SWIG_From_int((int)(FL_FREE_BOXTYPE)));
  SWIG_Python_SetConstant(d, "FL_MAX_BOXTYPE",SWIG_From_int((int)(FL_MAX_BOXTYPE)));
  SWIG_Python_SetConstant(d, "FL_NORMAL_LABEL",SWIG_From_int((int)(FL_NORMAL_LABEL)));
  SWIG_Python_SetConstant(d, "FL_NO_LABEL",SWIG_From_int((int)(FL_NO_LABEL)));
  SWIG_Python_SetConstant(d, "_FL_SHADOW_LABEL",SWIG_From_int((int)(_FL_SHADOW_LABEL)));
  SWIG_Python_SetConstant(d, "_FL_ENGRAVED_LABEL",SWIG_From_int((int)(_FL_ENGRAVED_LABEL)));
  SWIG_Python_SetConstant(d, "_FL_EMBOSSED_LABEL",SWIG_From_int((int)(_FL_EMBOSSED_LABEL)));
  SWIG_Python_SetConstant(d, "_FL_MULTI_LABEL",SWIG_From_int((int)(_FL_MULTI_LABEL)));
  SWIG_Python_SetConstant(d, "_FL_ICON_LABEL",SWIG_From_int((int)(_FL_ICON_LABEL)));
  SWIG_Python_SetConstant(d, "_FL_IMAGE_LABEL",SWIG_From_int((int)(_FL_IMAGE_LABEL)));
  SWIG_Python_SetConstant(d, "FL_FREE_LABELTYPE",SWIG_From_int((int)(FL_FREE_LABELTYPE)));
  SWIG_Python_SetConstant(d, "FL_NUM_FREE_COLOR",SWIG_From_int((int)(16)));
  SWIG_Python_SetConstant(d, "FL_NUM_GRAY",SWIG_From_int((int)(24)));
  SWIG_Python_SetConstant(d, "FL_NUM_RED",SWIG_From_int((int)(5)));
  SWIG_Python_SetConstant(d, "FL_NUM_GREEN",SWIG_From_int((int)(8)));
  SWIG_Python_SetConstant(d, "FL_NUM_BLUE",SWIG_From_int((int)(5)));
  SWIG_Python_SetConstant(d, "FL_CONTRAST_NONE",SWIG_From_int((int)(FL_CONTRAST_NONE)));
  SWIG_Python_SetConstant(d, "FL_CONTRAST_LEGACY",SWIG_From_int((int)(FL_CONTRAST_LEGACY)));
  SWIG_Python_SetConstant(d, "FL_CONTRAST_CIELAB",SWIG_From_int((int)(FL_CONTRAST_CIELAB)));
  SWIG_Python_SetConstant(d, "FL_CONTRAST_CUSTOM",SWIG_From_int((int)(FL_CONTRAST_CUSTOM)));
  SWIG_Python_SetConstant(d, "FL_CONTRAST_LAST",SWIG_From_int((int)(FL_CONTRAST_LAST)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_DEFAULT",SWIG_From_int((int)(FL_CURSOR_DEFAULT)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_ARROW",SWIG_From_int((int)(FL_CURSOR_ARROW)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_CROSS",SWIG_From_int((int)(FL_CURSOR_CROSS)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_WAIT",SWIG_From_int((int)(FL_CURSOR_WAIT)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_INSERT",SWIG_From_int((int)(FL_CURSOR_INSERT)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_HAND",SWIG_From_int((int)(FL_CURSOR_HAND)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_HELP",SWIG_From_int((int)(FL_CURSOR_HELP)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_MOVE",SWIG_From_int((int)(FL_CURSOR_MOVE)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_NS",SWIG_From_int((int)(FL_CURSOR_NS)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_WE",SWIG_From_int((int)(FL_CURSOR_WE)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_NWSE",SWIG_From_int((int)(FL_CURSOR_NWSE)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_NESW",SWIG_From_int((int)(FL_CURSOR_NESW)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_N",SWIG_From_int((int)(FL_CURSOR_N)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_NE",SWIG_From_int((int)(FL_CURSOR_NE)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_E",SWIG_From_int((int)(FL_CURSOR_E)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_SE",SWIG_From_int((int)(FL_CURSOR_SE)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_S",SWIG_From_int((int)(FL_CURSOR_S)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_SW",SWIG_From_int((int)(FL_CURSOR_SW)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_W",SWIG_From_int((int)(FL_CURSOR_W)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_NW",SWIG_From_int((int)(FL_CURSOR_NW)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_NONE",SWIG_From_int((int)(FL_CURSOR_NONE)));
  SWIG_Python_SetConstant(d, "FL_READ",SWIG_From_int((int)(FL_READ)));
  SWIG_Python_SetConstant(d, "FL_WRITE",SWIG_From_int((int)(FL_WRITE)));
  SWIG_Python_SetConstant(d, "FL_EXCEPT",SWIG_From_int((int)(FL_EXCEPT)));
  SWIG_Python_SetConstant(d, "FL_RGB",SWIG_From_int((int)(FL_RGB)));
  SWIG_Python_SetConstant(d, "FL_INDEX",SWIG_From_int((int)(FL_INDEX)));
  SWIG_Python_SetConstant(d, "FL_SINGLE",SWIG_From_int((int)(FL_SINGLE)));
  SWIG_Python_SetConstant(d, "FL_DOUBLE",SWIG_From_int((int)(FL_DOUBLE)));
  SWIG_Python_SetConstant(d, "FL_ACCUM",SWIG_From_int((int)(FL_ACCUM)));
  SWIG_Python_SetConstant(d, "FL_ALPHA",SWIG_From_int((int)(FL_ALPHA)));
  SWIG_Python_SetConstant(d, "FL_DEPTH",SWIG_From_int((int)(FL_DEPTH)));
  SWIG_Python_SetConstant(d, "FL_STENCIL",SWIG_From_int((int)(FL_STENCIL)));
  SWIG_Python_SetConstant(d, "FL_RGB8",SWIG_From_int((int)(FL_RGB8)));
  SWIG_Python_SetConstant(d, "FL_MULTISAMPLE",SWIG_From_int((int)(FL_MULTISAMPLE)));
  SWIG_Python_SetConstant(d, "FL_STEREO",SWIG_From_int((int)(FL_STEREO)));
  SWIG_Python_SetConstant(d, "FL_FAKE_SINGLE",SWIG_From_int((int)(FL_FAKE_SINGLE)));
  SWIG_Python_SetConstant(d, "FL_OPENGL3",SWIG_From_int((int)(FL_OPENGL3)));
  SWIG_Python_SetConstant(d, "FL_IMAGE_WITH_ALPHA",SWIG_From_int((int)(0x40000000)));
  SWIG_Python_SetConstant(d, "FL_DAMAGE_CHILD",SWIG_From_int((int)(FL_DAMAGE_CHILD)));
  SWIG_Python_SetConstant(d, "FL_DAMAGE_EXPOSE",SWIG_From_int((int)(FL_DAMAGE_EXPOSE)));
  SWIG_Python_SetConstant(d, "FL_DAMAGE_SCROLL",SWIG_From_int((int)(FL_DAMAGE_SCROLL)));
  SWIG_Python_SetConstant(d, "FL_DAMAGE_OVERLAY",SWIG_From_int((int)(FL_DAMAGE_OVERLAY)));
  SWIG_Python_SetConstant(d, "FL_DAMAGE_USER1",SWIG_From_int((int)(FL_DAMAGE_USER1)));
  SWIG_Python_SetConstant(d, "FL_DAMAGE_USER2",SWIG_From_int((int)(FL_DAMAGE_USER2)));
  SWIG_Python_SetConstant(d, "FL_DAMAGE_ALL",SWIG_From_int((int)(FL_DAMAGE_ALL)));
  SWIG_Python_SetConstant(d, "FL_ARROW_SINGLE",SWIG_From_int((int)(FL_ARROW_SINGLE)));
  SWIG_Python_SetConstant(d, "FL_ARROW_DOUBLE",SWIG_From_int((int)(FL_ARROW_DOUBLE)));
  SWIG_Python_SetConstant(d, "FL_ARROW_CHOICE",SWIG_From_int((int)(FL_ARROW_CHOICE)));
  SWIG_Python_SetConstant(d, "FL_ARROW_RETURN",SWIG_From_int((int)(FL_ARROW_RETURN)));
  SWIG_Python_SetConstant(d, "FL_ORIENT_NONE",SWIG_From_int((int)(FL_ORIENT_NONE)));
  SWIG_Python_SetConstant(d, "FL_ORIENT_RIGHT",SWIG_From_int((int)(FL_ORIENT_RIGHT)));
  SWIG_Python_SetConstant(d, "FL_ORIENT_NE",SWIG_From_int((int)(FL_ORIENT_NE)));
  SWIG_Python_SetConstant(d, "FL_ORIENT_UP",SWIG_From_int((int)(FL_ORIENT_UP)));
  SWIG_Python_SetConstant(d, "FL_ORIENT_NW",SWIG_From_int((int)(FL_ORIENT_NW)));
  SWIG_Python_SetConstant(d, "FL_ORIENT_LEFT",SWIG_From_int((int)(FL_ORIENT_LEFT)));
  SWIG_Python_SetConstant(d, "FL_ORIENT_SW",SWIG_From_int((int)(FL_ORIENT_SW)));
  SWIG_Python_SetConstant(d, "FL_ORIENT_DOWN",SWIG_From_int((int)(FL_ORIENT_DOWN)));
  SWIG_Python_SetConstant(d, "FL_ORIENT_SE",SWIG_From_int((int)(FL_ORIENT_SE)));
  SWIG_Python_SetConstant(d, "FL_RGB_SCALING_NEAREST",SWIG_From_int((int)(FL_RGB_SCALING_NEAREST)));
  SWIG_Python_SetConstant(d, "FL_RGB_SCALING_BILINEAR",SWIG_From_int((int)(FL_RGB_SCALING_BILINEAR)));
  SWIG_Python_SetConstant(d, "FL_RESERVED_TYPE",SWIG_From_int((int)(100)));
  SWIG_Python_SetConstant(d, "FL_NORMAL_BROWSER",SWIG_From_int((int)(0)));
  SWIG_Python_SetConstant(d, "FL_SELECT_BROWSER",SWIG_From_int((int)(1)));
  SWIG_Python_SetConstant(d, "FL_HOLD_BROWSER",SWIG_From_int((int)(2)));
  SWIG_Python_SetConstant(d, "FL_MULTI_BROWSER",SWIG_From_int((int)(3)));
  SWIG_Python_SetConstant(d, "FL_SORT_ASCENDING",SWIG_From_int((int)(0)));
  SWIG_Python_SetConstant(d, "FL_SORT_DESCENDING",SWIG_From_int((int)(1)));
  SWIG_Python_SetConstant(d, "FL_SORT_CASEINSENSITIVE",SWIG_From_int((int)(0x2)));
  SWIG_Python_SetConstant(d, "Fl_Browser__HORIZONTAL",SWIG_From_int((int)(Fl_Browser_::HORIZONTAL)));
  SWIG_Python_SetConstant(d, "Fl_Browser__VERTICAL",SWIG_From_int((int)(Fl_Browser_::VERTICAL)));
  SWIG_Python_SetConstant(d, "Fl_Browser__BOTH",SWIG_From_int((int)(Fl_Browser_::BOTH)));
  SWIG_Python_SetConstant(d, "Fl_Browser__ALWAYS_ON",SWIG_From_int((int)(Fl_Browser_::ALWAYS_ON)));
  SWIG_Python_SetConstant(d, "Fl_Browser__HORIZONTAL_ALWAYS",SWIG_From_int((int)(Fl_Browser_::HORIZONTAL_ALWAYS)));
  SWIG_Python_SetConstant(d, "Fl_Browser__VERTICAL_ALWAYS",SWIG_From_int((int)(Fl_Browser_::VERTICAL_ALWAYS)));
  SWIG_Python_SetConstant(d, "Fl_Browser__BOTH_ALWAYS",SWIG_From_int((int)(Fl_Browser_::BOTH_ALWAYS)));
  SWIG_Python_SetConstant(d, "Fl_Browser_TOP",SWIG_From_int((int)(Fl_Browser::TOP)));
  SWIG_Python_SetConstant(d, "Fl_Browser_BOTTOM",SWIG_From_int((int)(Fl_Browser::BOTTOM)));
  SWIG_Python_SetConstant(d, "Fl_Browser_MIDDLE",SWIG_From_int((int)(Fl_Browser::MIDDLE)));
  SWIG_Python_SetConstant(d, "Fl_File_Browser_FILES",SWIG_From_int((int)(Fl_File_Browser::FILES)));
  SWIG_Python_SetConstant(d, "Fl_File_Browser_DIRECTORIES",SWIG_From_int((int)(Fl_File_Browser::DIRECTORIES)));
  SWIG_Python_SetConstant(d, "FL_ALPHASORT",SWIG_From_int((int)(FL_ALPHASORT)));
  SWIG_Python_SetConstant(d, "FL_CASEALPHASORT",SWIG_From_int((int)(FL_CASEALPHASORT)));
  SWIG_Python_SetConstant(d, "FL_CASENUMERICSORT",SWIG_From_int((int)(FL_CASENUMERICSORT)));
  SWIG_Python_SetConstant(d, "FL_NUMERICSORT",SWIG_From_int((int)(FL_NUMERICSORT)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_ANY",SWIG_From_int((int)(Fl_File_Icon::ANY)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_PLAIN",SWIG_From_int((int)(Fl_File_Icon::PLAIN)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_FIFO",SWIG_From_int((int)(Fl_File_Icon::FIFO)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_DEVICE",SWIG_From_int((int)(Fl_File_Icon::DEVICE)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_LINK",SWIG_From_int((int)(Fl_File_Icon::LINK)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_DIRECTORY",SWIG_From_int((int)(Fl_File_Icon::DIRECTORY)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_END",SWIG_From_int((int)(Fl_File_Icon::END)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_COLOR",SWIG_From_int((int)(Fl_File_Icon::COLOR)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_LINE",SWIG_From_int((int)(Fl_File_Icon::LINE)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_CLOSEDLINE",SWIG_From_int((int)(Fl_File_Icon::CLOSEDLINE)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_POLYGON",SWIG_From_int((int)(Fl_File_Icon::POLYGON)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_OUTLINEPOLYGON",SWIG_From_int((int)(Fl_File_Icon::OUTLINEPOLYGON)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_VERTEX",SWIG_From_int((int)(Fl_File_Icon::VERTEX)));
  SWIG_Python_SetConstant(d, "Fl_File_Chooser_SINGLE",SWIG_From_int((int)(Fl_File_Chooser::SINGLE)));
  SWIG_Python_SetConstant(d, "Fl_File_Chooser_MULTI",SWIG_From_int((int)(Fl_File_Chooser::MULTI)));
  SWIG_Python_SetConstant(d, "Fl_File_Chooser_CREATE",SWIG_From_int((int)(Fl_File_Chooser::CREATE)));
  SWIG_Python_SetConstant(d, "Fl_File_Chooser_DIRECTORY",SWIG_From_int((int)(Fl_File_Chooser::DIRECTORY)));
  SWIG_Python_SetConstant(d, "FL_PATH_MAX",SWIG_From_int((int)(2048)));
  SWIG_Python_SetConstant(d, "FLTK_INCLUDE_FL_ASK",SWIG_From_int((int)(1)));
  SWIG_Python_SetConstant(d, "FL_BEEP_DEFAULT",SWIG_From_int((int)(FL_BEEP_DEFAULT)));
  SWIG_Python_SetConstant(d, "FL_BEEP_MESSAGE",SWIG_From_int((int)(FL_BEEP_MESSAGE)));
  SWIG_Python_SetConstant(d, "FL_BEEP_ERROR",SWIG_From_int((int)(FL_BEEP_ERROR)));
  SWIG_Python_SetConstant(d, "FL_BEEP_QUESTION",SWIG_From_int((int)(FL_BEEP_QUESTION)));
  SWIG_Python_SetConstant(d, "FL_BEEP_PASSWORD",SWIG_From_int((int)(FL_BEEP_PASSWORD)));
  SWIG_Python_SetConstant(d, "FL_BEEP_NOTIFICATION",SWIG_From_int((int)(FL_BEEP_NOTIFICATION)));
  SWIG_Python_SetConstant(d, "FL_NORMAL_BUTTON",SWIG_From_int((int)(0)));
  SWIG_Python_SetConstant(d, "FL_TOGGLE_BUTTON",SWIG_From_int((int)(1)));
  SWIG_Python_SetConstant(d, "FL_RADIO_BUTTON",SWIG_From_int((int)((100+2))));
  SWIG_Python_SetConstant(d, "FL_HIDDEN_BUTTON",SWIG_From_int((int)(3)));
  SWIG_Python_SetConstant(d, "FL_BAR_CHART",SWIG_From_int((int)(0)));
  SWIG_Python_SetConstant(d, "FL_HORBAR_CHART",SWIG_From_int((int)(1)));
  SWIG_Python_SetConstant(d, "FL_LINE_CHART",SWIG_From_int((int)(2)));
  SWIG_Python_SetConstant(d, "FL_FILL_CHART",SWIG_From_int((int)(3)));
  SWIG_Python_SetConstant(d, "FL_SPIKE_CHART",SWIG_From_int((int)(4)));
  SWIG_Python_SetConstant(d, "FL_PIE_CHART",SWIG_From_int((int)(5)));
  SWIG_Python_SetConstant(d, "FL_SPECIALPIE_CHART",SWIG_From_int((int)(6)));
  SWIG_Python_SetConstant(d, "FL_FILLED_CHART",SWIG_From_int((int)(3)));
  SWIG_Python_SetConstant(d, "FL_CHART_MAX",SWIG_From_int((int)(128)));
  SWIG_Python_SetConstant(d, "FL_CHART_LABEL_MAX",SWIG_From_int((int)(18)));
  SWIG_Python_SetConstant(d, "FL_SQUARE_CLOCK",SWIG_From_int((int)(0)));
  SWIG_Python_SetConstant(d, "FL_ROUND_CLOCK",SWIG_From_int((int)(1)));
  SWIG_Python_SetConstant(d, "FL_ANALOG_CLOCK",SWIG_From_int((int)(0)));
  SWIG_Python_SetConstant(d, "FL_DIGITAL_CLOCK",SWIG_From_int((int)(0)));
  SWIG_Python_SetConstant(d, "FL_NORMAL_COUNTER",SWIG_From_int((int)(0)));
  SWIG_Python_SetConstant(d, "FL_SIMPLE_COUNTER",SWIG_From_int((int)(1)));
  SWIG_Python_SetConstant(d, "FL_NORMAL_DIAL",SWIG_From_int((int)(0)));
  SWIG_Python_SetConstant(d, "FL_LINE_DIAL",SWIG_From_int((int)(1)));
  SWIG_Python_SetConstant(d, "FL_FILL_DIAL",SWIG_From_int((int)(2)));
  SWIG_Python_SetConstant(d, "FL_WINDOW",SWIG_From_int((int)(0xF0)));
  SWIG_Python_SetConstant(d, "FL_DOUBLE_WINDOW",SWIG_From_int((int)(0xF1)));
  SWIG_Python_SetConstant(d, "FL_SOLID",SWIG_From_int((int)(FL_SOLID)));
  SWIG_Python_SetConstant(d, "FL_DASH",SWIG_From_int((int)(FL_DASH)));
  SWIG_Python_SetConstant(d, "FL_DOT",SWIG_From_int((int)(FL_DOT)));
  SWIG_Python_SetConstant(d, "FL_DASHDOT",SWIG_From_int((int)(FL_DASHDOT)));
  SWIG_Python_SetConstant(d, "FL_DASHDOTDOT",SWIG_From_int((int)(FL_DASHDOTDOT)));
  SWIG_Python_SetConstant(d, "FL_CAP_FLAT",SWIG_From_int((int)(FL_CAP_FLAT)));
  SWIG_Python_SetConstant(d, "FL_CAP_ROUND",SWIG_From_int((int)(FL_CAP_ROUND)));
  SWIG_Python_SetConstant(d, "FL_CAP_SQUARE",SWIG_From_int((int)(FL_CAP_SQUARE)));
  SWIG_Python_SetConstant(d, "FL_JOIN_MITER",SWIG_From_int((int)(FL_JOIN_MITER)));
  SWIG_Python_SetConstant(d, "FL_JOIN_ROUND",SWIG_From_int((int)(FL_JOIN_ROUND)));
  SWIG_Python_SetConstant(d, "FL_JOIN_BEVEL",SWIG_From_int((int)(FL_JOIN_BEVEL)));
  SWIG_Python_SetConstant(d, "FL_UNIFORM_WIDTH",SWIG_From_int((int)(FL_UNIFORM_WIDTH)));
  SWIG_Python_SetConstant(d, "FL_NORMAL_INPUT",SWIG_From_int((int)(0)));
  SWIG_Python_SetConstant(d, "FL_FLOAT_INPUT",SWIG_From_int((int)(1)));
  SWIG_Python_SetConstant(d, "FL_INT_INPUT",SWIG_From_int((int)(2)));
  SWIG_Python_SetConstant(d, "FL_HIDDEN_INPUT",SWIG_From_int((int)(3)));
  SWIG_Python_SetConstant(d, "FL_MULTILINE_INPUT",SWIG_From_int((int)(4)));
  SWIG_Python_SetConstant(d, "FL_SECRET_INPUT",SWIG_From_int((int)(5)));
  SWIG_Python_SetConstant(d, "FL_INPUT_TYPE",SWIG_From_int((int)(7)));
  SWIG_Python_SetConstant(d, "FL_INPUT_READONLY",SWIG_From_int((int)(8)));
  SWIG_Python_SetConstant(d, "FL_NORMAL_OUTPUT",SWIG_From_int((int)((0|8))));
  SWIG_Python_SetConstant(d, "FL_MULTILINE_OUTPUT",SWIG_From_int((int)((4|8))));
  SWIG_Python_SetConstant(d, "FL_INPUT_WRAP",SWIG_From_int((int)(16)));
  SWIG_Python_SetConstant(d, "FL_MULTILINE_INPUT_WRAP",SWIG_From_int((int)((4|16))));
  SWIG_Python_SetConstant(d, "FL_MULTILINE_OUTPUT_WRAP",SWIG_From_int((int)((4|8|16))));
  SWIG_Python_SetConstant(d, "FL_VERT_SLIDER",SWIG_From_int((int)(0)));
  SWIG_Python_SetConstant(d, "FL_HOR_SLIDER",SWIG_From_int((int)(1)));
  SWIG_Python_SetConstant(d, "FL_VERT_FILL_SLIDER",SWIG_From_int((int)(2)));
  SWIG_Python_SetConstant(d, "FL_HOR_FILL_SLIDER",SWIG_From_int((int)(3)));
  SWIG_Python_SetConstant(d, "FL_VERT_NICE_SLIDER",SWIG_From_int((int)(4)));
  SWIG_Python_SetConstant(d, "FL_HOR_NICE_SLIDER",SWIG_From_int((int)(5)));
  SWIG_Python_SetConstant(d, "Fl_Slider_TICKS_NONE",SWIG_From_int((int)(Fl_Slider::TICKS_NONE)));
  SWIG_Python_SetConstant(d, "Fl_Slider_TICKS_BELOW",SWIG_From_int((int)(Fl_Slider::TICKS_BELOW)));
  SWIG_Python_SetConstant(d, "Fl_Slider_TICKS_ABOVE",SWIG_From_int((int)(Fl_Slider::TICKS_ABOVE)));
  SWIG_Python_SetConstant(d, "Fl_Slider_TICKS_LEFT",SWIG_From_int((int)(Fl_Slider::TICKS_LEFT)));
  SWIG_Python_SetConstant(d, "Fl_Slider_TICKS_RIGHT",SWIG_From_int((int)(Fl_Slider::TICKS_RIGHT)));
  SWIG_Python_SetConstant(d, "Fl_Slider_LINEAR_SCALE",SWIG_From_int((int)(Fl_Slider::LINEAR_SCALE)));
  SWIG_Python_SetConstant(d, "Fl_Slider_LOG_SCALE",SWIG_From_int((int)(Fl_Slider::LOG_SCALE)));
  SWIG_Python_SetConstant(d, "Fl_Flex_VERTICAL",SWIG_From_int((int)(Fl_Flex::VERTICAL)));
  SWIG_Python_SetConstant(d, "Fl_Flex_HORIZONTAL",SWIG_From_int((int)(Fl_Flex::HORIZONTAL)));
  SWIG_Python_SetConstant(d, "Fl_Flex_COLUMN",SWIG_From_int((int)(Fl_Flex::COLUMN)));
  SWIG_Python_SetConstant(d, "Fl_Flex_ROW",SWIG_From_int((int)(Fl_Flex::ROW)));
  SWIG_Python_SetConstant(d, "Fl_Anim_GIF_Image_DONT_START",SWIG_From_int((int)(Fl_Anim_GIF_Image::DONT_START)));
  SWIG_Python_SetConstant(d, "Fl_Anim_GIF_Image_DONT_RESIZE_CANVAS",SWIG_From_int((int)(Fl_Anim_GIF_Image::DONT_RESIZE_CANVAS)));
  SWIG_Python_SetConstant(d, "Fl_Anim_GIF_Image_DONT_SET_AS_IMAGE",SWIG_From_int((int)(Fl_Anim_GIF_Image::DONT_SET_AS_IMAGE)));
  SWIG_Python_SetConstant(d, "Fl_Anim_GIF_Image_OPTIMIZE_MEMORY",SWIG_From_int((int)(Fl_Anim_GIF_Image::OPTIMIZE_MEMORY)));
  SWIG_Python_SetConstant(d, "Fl_Anim_GIF_Image_LOG_FLAG",SWIG_From_int((int)(Fl_Anim_GIF_Image::LOG_FLAG)));
  SWIG_Python_SetConstant(d, "Fl_Anim_GIF_Image_DEBUG_FLAG",SWIG_From_int((int)(Fl_Anim_GIF_Image::DEBUG_FLAG)));
  SWIG_Python_SetConstant(d, "Fl_Menu_Button_POPUP1",SWIG_From_int((int)(Fl_Menu_Button::POPUP1)));
  SWIG_Python_SetConstant(d, "Fl_Menu_Button_POPUP2",SWIG_From_int((int)(Fl_Menu_Button::POPUP2)));
  SWIG_Python_SetConstant(d, "Fl_Menu_Button_POPUP12",SWIG_From_int((int)(Fl_Menu_Button::POPUP12)));
  SWIG_Python_SetConstant(d, "Fl_Menu_Button_POPUP3",SWIG_From_int((int)(Fl_Menu_Button::POPUP3)));
  SWIG_Python_SetConstant(d, "Fl_Menu_Button_POPUP13",SWIG_From_int((int)(Fl_Menu_Button::POPUP13)));
  SWIG_Python_SetConstant(d, "Fl_Menu_Button_POPUP23",SWIG_From_int((int)(Fl_Menu_Button::POPUP23)));
  SWIG_Python_SetConstant(d, "Fl_Menu_Button_POPUP123",SWIG_From_int((int)(Fl_Menu_Button::POPUP123)));
  SWIG_Python_SetConstant(d, "FL_MENU_INACTIVE",SWIG_From_int((int)(FL_MENU_INACTIVE)));
  SWIG_Python_SetConstant(d, "FL_MENU_TOGGLE",SWIG_From_int((int)(FL_MENU_TOGGLE)));
  SWIG_Python_SetConstant(d, "FL_MENU_VALUE",SWIG_From_int((int)(FL_MENU_VALUE)));
  SWIG_Python_SetConstant(d, "FL_MENU_RADIO",SWIG_From_int((int)(FL_MENU_RADIO)));
  SWIG_Python_SetConstant(d, "FL_MENU_INVISIBLE",SWIG_From_int((int)(FL_MENU_INVISIBLE)));
  SWIG_Python_SetConstant(d, "FL_SUBMENU_POINTER",SWIG_From_int((int)(FL_SUBMENU_POINTER)));
  SWIG_Python_SetConstant(d, "FL_SUBMENU",SWIG_From_int((int)(FL_SUBMENU)));
  SWIG_Python_SetConstant(d, "FL_MENU_DIVIDER",SWIG_From_int((int)(FL_MENU_DIVIDER)));
  SWIG_Python_SetConstant(d, "FL_MENU_HORIZONTAL",SWIG_From_int((int)(FL_MENU_HORIZONTAL)));
  SWIG_Python_SetConstant(d, "FL_MENU_CHATTY",SWIG_From_int((int)(FL_MENU_CHATTY)));
  SWIG_Python_SetConstant(d, "FL_MENU_HEADLINE",SWIG_From_int((int)(FL_MENU_HEADLINE)));
  SWIG_Python_SetConstant(d, "FL_PUP_NONE",SWIG_From_int((int)(FL_PUP_NONE)));
  SWIG_Python_SetConstant(d, "FL_PUP_GREY",SWIG_From_int((int)(FL_PUP_GREY)));
  SWIG_Python_SetConstant(d, "FL_PUP_GRAY",SWIG_From_int((int)(FL_PUP_GRAY)));
  SWIG_Python_SetConstant(d, "FL_MENU_BOX",SWIG_From_int((int)(FL_MENU_BOX)));
  SWIG_Python_SetConstant(d, "FL_PUP_BOX",SWIG_From_int((int)(FL_PUP_BOX)));
  SWIG_Python_SetConstant(d, "FL_MENU_CHECK",SWIG_From_int((int)(FL_MENU_CHECK)));
  SWIG_Python_SetConstant(d, "FL_PUP_CHECK",SWIG_From_int((int)(FL_PUP_CHECK)));
  SWIG_Python_SetConstant(d, "FL_PUP_RADIO",SWIG_From_int((int)(FL_PUP_RADIO)));
  SWIG_Python_SetConstant(d, "FL_PUP_INVISIBLE",SWIG_From_int((int)(FL_PUP_INVISIBLE)));
  SWIG_Python_SetConstant(d, "FL_PUP_SUBMENU",SWIG_From_int((int)(FL_PUP_SUBMENU)));
  SWIG_Python_SetConstant(d, "Fl_Native_File_Chooser_BROWSE_FILE",SWIG_From_int((int)(Fl_Native_File_Chooser::BROWSE_FILE)));
  SWIG_Python_SetConstant(d, "Fl_Native_File_Chooser_BROWSE_DIRECTORY",SWIG_From_int((int)(Fl_Native_File_Chooser::BROWSE_DIRECTORY)));
  SWIG_Python_SetConstant(d, "Fl_Native_File_Chooser_BROWSE_MULTI_FILE",SWIG_From_int((int)(Fl_Native_File_Chooser::BROWSE_MULTI_FILE)));
  SWIG_Python_SetConstant(d, "Fl_Native_File_Chooser_BROWSE_MULTI_DIRECTORY",SWIG_From_int((int)(Fl_Native_File_Chooser::BROWSE_MULTI_DIRECTORY)));
  SWIG_Python_SetConstant(d, "Fl_Native_File_Chooser_BROWSE_SAVE_FILE",SWIG_From_int((int)(Fl_Native_File_Chooser::BROWSE_SAVE_FILE)));
  SWIG_Python_SetConstant(d, "Fl_Native_File_Chooser_BROWSE_SAVE_DIRECTORY",SWIG_From_int((int)(Fl_Native_File_Chooser::BROWSE_SAVE_DIRECTORY)));
  SWIG_Python_SetConstant(d, "Fl_Native_File_Chooser_NO_OPTIONS",SWIG_From_int((int)(Fl_Native_File_Chooser::NO_OPTIONS)));
  SWIG_Python_SetConstant(d, "Fl_Native_File_Chooser_SAVEAS_CONFIRM",SWIG_From_int((int)(Fl_Native_File_Chooser::SAVEAS_CONFIRM)));
  SWIG_Python_SetConstant(d, "Fl_Native_File_Chooser_NEW_FOLDER",SWIG_From_int((int)(Fl_Native_File_Chooser::NEW_FOLDER)));
  SWIG_Python_SetConstant(d, "Fl_Native_File_Chooser_PREVIEW",SWIG_From_int((int)(Fl_Native_File_Chooser::PREVIEW)));
  SWIG_Python_SetConstant(d, "Fl_Native_File_Chooser_USE_FILTER_EXT",SWIG_From_int((int)(Fl_Native_File_Chooser::USE_FILTER_EXT)));
  SWIG_Python_SetConstant(d, "Fl_Pack_VERTICAL",SWIG_From_int((int)(Fl_Pack::VERTICAL)));
  SWIG_Python_SetConstant(d, "Fl_Pack_HORIZONTAL",SWIG_From_int((int)(Fl_Pack::HORIZONTAL)));
  SWIG_Python_SetConstant(d, "Fl_Preferences_SYSTEM",SWIG_From_int((int)(Fl_Preferences::SYSTEM)));
  SWIG_Python_SetConstant(d, "Fl_Preferences_USER",SWIG_From_int((int)(Fl_Preferences::USER)));
  SWIG_Python_SetConstant(d, "Fl_Scroll_HORIZONTAL",SWIG_From_int((int)(Fl_Scroll::HORIZONTAL)));
  SWIG_Python_SetConstant(d, "Fl_Scroll_VERTICAL",SWIG_From_int((int)(Fl_Scroll::VERTICAL)));
  SWIG_Python_SetConstant(d, "Fl_Scroll_BOTH",SWIG_From_int((int)(Fl_Scroll::BOTH)));
  SWIG_Python_SetConstant(d, "Fl_Scroll_ALWAYS_ON",SWIG_From_int((int)(Fl_Scroll::ALWAYS_ON)));
  SWIG_Python_SetConstant(d, "Fl_Scroll_HORIZONTAL_ALWAYS",SWIG_From_int((int)(Fl_Scroll::HORIZONTAL_ALWAYS)));
  SWIG_Python_SetConstant(d, "Fl_Scroll_VERTICAL_ALWAYS",SWIG_From_int((int)(Fl_Scroll::VERTICAL_ALWAYS)));
  SWIG_Python_SetConstant(d, "Fl_Scroll_BOTH_ALWAYS",SWIG_From_int((int)(Fl_Scroll::BOTH_ALWAYS)));
  SWIG_Python_SetConstant(d, "Fl_Sys_Menu_Bar_no_window_menu",SWIG_From_int((int)(Fl_Sys_Menu_Bar::no_window_menu)));
  SWIG_Python_SetConstant(d, "Fl_Sys_Menu_Bar_tabbing_mode_none",SWIG_From_int((int)(Fl_Sys_Menu_Bar::tabbing_mode_none)));
  SWIG_Python_SetConstant(d, "Fl_Sys_Menu_Bar_tabbing_mode_automatic",SWIG_From_int((int)(Fl_Sys_Menu_Bar::tabbing_mode_automatic)));
  SWIG_Python_SetConstant(d, "Fl_Sys_Menu_Bar_tabbing_mode_preferred",SWIG_From_int((int)(Fl_Sys_Menu_Bar::tabbing_mode_preferred)));
  SWIG_Python_SetConstant(d, "Fl_Table_CONTEXT_NONE",SWIG_From_int((int)(Fl_Table::CONTEXT_NONE)));
  SWIG_Python_SetConstant(d, "Fl_Table_CONTEXT_STARTPAGE",SWIG_From_int((int)(Fl_Table::CONTEXT_STARTPAGE)));
  SWIG_Python_SetConstant(d, "Fl_Table_CONTEXT_ENDPAGE",SWIG_From_int((int)(Fl_Table::CONTEXT_ENDPAGE)));
  SWIG_Python_SetConstant(d, "Fl_Table_CONTEXT_ROW_HEADER",SWIG_From_int((int)(Fl_Table::CONTEXT_ROW_HEADER)));
  SWIG_Python_SetConstant(d, "Fl_Table_CONTEXT_COL_HEADER",SWIG_From_int((int)(Fl_Table::CONTEXT_COL_HEADER)));
  SWIG_Python_SetConstant(d, "Fl_Table_CONTEXT_CELL",SWIG_From_int((int)(Fl_Table::CONTEXT_CELL)));
  SWIG_Python_SetConstant(d, "Fl_Table_CONTEXT_TABLE",SWIG_From_int((int)(Fl_Table::CONTEXT_TABLE)));
  SWIG_Python_SetConstant(d, "Fl_Table_CONTEXT_RC_RESIZE",SWIG_From_int((int)(Fl_Table::CONTEXT_RC_RESIZE)));
  SWIG_Python_SetConstant(d, "Fl_Table_Row_SELECT_NONE",SWIG_From_int((int)(Fl_Table_Row::SELECT_NONE)));
  SWIG_Python_SetConstant(d, "Fl_Table_Row_SELECT_SINGLE",SWIG_From_int((int)(Fl_Table_Row::SELECT_SINGLE)));
  SWIG_Python_SetConstant(d, "Fl_Table_Row_SELECT_MULTI",SWIG_From_int((int)(Fl_Table_Row::SELECT_MULTI)));
  SWIG_Python_SetConstant(d, "Fl_Tabs_OVERFLOW_COMPRESS",SWIG_From_int((int)(Fl_Tabs::OVERFLOW_COMPRESS)));
  SWIG_Python_SetConstant(d, "Fl_Tabs_OVERFLOW_CLIP",SWIG_From_int((int)(Fl_Tabs::OVERFLOW_CLIP)));
  SWIG_Python_SetConstant(d, "Fl_Tabs_OVERFLOW_PULLDOWN",SWIG_From_int((int)(Fl_Tabs::OVERFLOW_PULLDOWN)));
  SWIG_Python_SetConstant(d, "Fl_Tabs_OVERFLOW_DRAG",SWIG_From_int((int)(Fl_Tabs::OVERFLOW_DRAG)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_NO_REDRAW",SWIG_From_int((int)(Fl_Terminal::NO_REDRAW)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_RATE_LIMITED",SWIG_From_int((int)(Fl_Terminal::RATE_LIMITED)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_PER_WRITE",SWIG_From_int((int)(Fl_Terminal::PER_WRITE)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_NORMAL",SWIG_From_int((int)(Fl_Terminal::NORMAL)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_BOLD",SWIG_From_int((int)(Fl_Terminal::BOLD)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_DIM",SWIG_From_int((int)(Fl_Terminal::DIM)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_ITALIC",SWIG_From_int((int)(Fl_Terminal::ITALIC)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_UNDERLINE",SWIG_From_int((int)(Fl_Terminal::UNDERLINE)));
  SWIG_Python_SetConstant(d, "Fl_Terminal__RESERVED_1",SWIG_From_int((int)(Fl_Terminal::_RESERVED_1)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_INVERSE",SWIG_From_int((int)(Fl_Terminal::INVERSE)));
  SWIG_Python_SetConstant(d, "Fl_Terminal__RESERVED_2",SWIG_From_int((int)(Fl_Terminal::_RESERVED_2)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_STRIKEOUT",SWIG_From_int((int)(Fl_Terminal::STRIKEOUT)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_FG_XTERM",SWIG_From_int((int)(Fl_Terminal::FG_XTERM)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_BG_XTERM",SWIG_From_int((int)(Fl_Terminal::BG_XTERM)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_EOL",SWIG_From_int((int)(Fl_Terminal::EOL)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_RESV_A",SWIG_From_int((int)(Fl_Terminal::RESV_A)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_RESV_B",SWIG_From_int((int)(Fl_Terminal::RESV_B)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_RESV_C",SWIG_From_int((int)(Fl_Terminal::RESV_C)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_RESV_D",SWIG_From_int((int)(Fl_Terminal::RESV_D)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_RESV_E",SWIG_From_int((int)(Fl_Terminal::RESV_E)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_COLORMASK",SWIG_From_int((int)(Fl_Terminal::COLORMASK)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_OFF",SWIG_From_int((int)(Fl_Terminal::OFF)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_CR_TO_LF",SWIG_From_int((int)(Fl_Terminal::CR_TO_LF)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_LF_TO_CR",SWIG_From_int((int)(Fl_Terminal::LF_TO_CR)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_LF_TO_CRLF",SWIG_From_int((int)(Fl_Terminal::LF_TO_CRLF)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_SCROLLBAR_OFF",SWIG_From_int((int)(Fl_Terminal::SCROLLBAR_OFF)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_SCROLLBAR_AUTO",SWIG_From_int((int)(Fl_Terminal::SCROLLBAR_AUTO)));
  SWIG_Python_SetConstant(d, "Fl_Terminal_SCROLLBAR_ON",SWIG_From_int((int)(Fl_Terminal::SCROLLBAR_ON)));
  SWIG_Python_SetConstant(d, "FL_TEXT_MAX_EXP_CHAR_LEN",SWIG_From_int((int)(20)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_NORMAL_CURSOR",SWIG_From_int((int)(Fl_Text_Display::NORMAL_CURSOR)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_CARET_CURSOR",SWIG_From_int((int)(Fl_Text_Display::CARET_CURSOR)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_DIM_CURSOR",SWIG_From_int((int)(Fl_Text_Display::DIM_CURSOR)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_BLOCK_CURSOR",SWIG_From_int((int)(Fl_Text_Display::BLOCK_CURSOR)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_HEAVY_CURSOR",SWIG_From_int((int)(Fl_Text_Display::HEAVY_CURSOR)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_SIMPLE_CURSOR",SWIG_From_int((int)(Fl_Text_Display::SIMPLE_CURSOR)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_CURSOR_POS",SWIG_From_int((int)(Fl_Text_Display::CURSOR_POS)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_CHARACTER_POS",SWIG_From_int((int)(Fl_Text_Display::CHARACTER_POS)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_DRAG_NONE",SWIG_From_int((int)(Fl_Text_Display::DRAG_NONE)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_DRAG_START_DND",SWIG_From_int((int)(Fl_Text_Display::DRAG_START_DND)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_DRAG_CHAR",SWIG_From_int((int)(Fl_Text_Display::DRAG_CHAR)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_DRAG_WORD",SWIG_From_int((int)(Fl_Text_Display::DRAG_WORD)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_DRAG_LINE",SWIG_From_int((int)(Fl_Text_Display::DRAG_LINE)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_WRAP_NONE",SWIG_From_int((int)(Fl_Text_Display::WRAP_NONE)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_WRAP_AT_COLUMN",SWIG_From_int((int)(Fl_Text_Display::WRAP_AT_COLUMN)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_WRAP_AT_PIXEL",SWIG_From_int((int)(Fl_Text_Display::WRAP_AT_PIXEL)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_WRAP_AT_BOUNDS",SWIG_From_int((int)(Fl_Text_Display::WRAP_AT_BOUNDS)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_ATTR_BGCOLOR",SWIG_From_int((int)(Fl_Text_Display::ATTR_BGCOLOR)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_ATTR_BGCOLOR_EXT_",SWIG_From_int((int)(Fl_Text_Display::ATTR_BGCOLOR_EXT_)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_ATTR_BGCOLOR_EXT",SWIG_From_int((int)(Fl_Text_Display::ATTR_BGCOLOR_EXT)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_ATTR_UNDERLINE",SWIG_From_int((int)(Fl_Text_Display::ATTR_UNDERLINE)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_ATTR_GRAMMAR",SWIG_From_int((int)(Fl_Text_Display::ATTR_GRAMMAR)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_ATTR_SPELLING",SWIG_From_int((int)(Fl_Text_Display::ATTR_SPELLING)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_ATTR_STRIKE_THROUGH",SWIG_From_int((int)(Fl_Text_Display::ATTR_STRIKE_THROUGH)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_ATTR_LINES_MASK",SWIG_From_int((int)(Fl_Text_Display::ATTR_LINES_MASK)));
  SWIG_Python_SetConstant(d, "FL_TEXT_EDITOR_ANY_STATE",SWIG_From_long((long)((-1L))));
  SWIG_Python_SetConstant(d, "FL_TREE_SORT_NONE",SWIG_From_int((int)(FL_TREE_SORT_NONE)));
  SWIG_Python_SetConstant(d, "FL_TREE_SORT_ASCENDING",SWIG_From_int((int)(FL_TREE_SORT_ASCENDING)));
  SWIG_Python_SetConstant(d, "FL_TREE_SORT_DESCENDING",SWIG_From_int((int)(FL_TREE_SORT_DESCENDING)));
  SWIG_Python_SetConstant(d, "FL_TREE_CONNECTOR_NONE",SWIG_From_int((int)(FL_TREE_CONNECTOR_NONE)));
  SWIG_Python_SetConstant(d, "FL_TREE_CONNECTOR_DOTTED",SWIG_From_int((int)(FL_TREE_CONNECTOR_DOTTED)));
  SWIG_Python_SetConstant(d, "FL_TREE_CONNECTOR_SOLID",SWIG_From_int((int)(FL_TREE_CONNECTOR_SOLID)));
  SWIG_Python_SetConstant(d, "FL_TREE_SELECT_NONE",SWIG_From_int((int)(FL_TREE_SELECT_NONE)));
  SWIG_Python_SetConstant(d, "FL_TREE_SELECT_SINGLE",SWIG_From_int((int)(FL_TREE_SELECT_SINGLE)));
  SWIG_Python_SetConstant(d, "FL_TREE_SELECT_MULTI",SWIG_From_int((int)(FL_TREE_SELECT_MULTI)));
  SWIG_Python_SetConstant(d, "FL_TREE_SELECT_SINGLE_DRAGGABLE",SWIG_From_int((int)(FL_TREE_SELECT_SINGLE_DRAGGABLE)));
  SWIG_Python_SetConstant(d, "FL_TREE_SELECTABLE_ONCE",SWIG_From_int((int)(FL_TREE_SELECTABLE_ONCE)));
  SWIG_Python_SetConstant(d, "FL_TREE_SELECTABLE_ALWAYS",SWIG_From_int((int)(FL_TREE_SELECTABLE_ALWAYS)));
  SWIG_Python_SetConstant(d, "FL_TREE_ITEM_DRAW_DEFAULT",SWIG_From_int((int)(FL_TREE_ITEM_DRAW_DEFAULT)));
  SWIG_Python_SetConstant(d, "FL_TREE_ITEM_DRAW_LABEL_AND_WIDGET",SWIG_From_int((int)(FL_TREE_ITEM_DRAW_LABEL_AND_WIDGET)));
  SWIG_Python_SetConstant(d, "FL_TREE_ITEM_HEIGHT_FROM_WIDGET",SWIG_From_int((int)(FL_TREE_ITEM_HEIGHT_FROM_WIDGET)));
  SWIG_Python_SetConstant(d, "FL_TREE_REASON_NONE",SWIG_From_int((int)(FL_TREE_REASON_NONE)));
  SWIG_Python_SetConstant(d, "FL_TREE_REASON_SELECTED",SWIG_From_int((int)(FL_TREE_REASON_SELECTED)));
  SWIG_Python_SetConstant(d, "FL_TREE_REASON_DESELECTED",SWIG_From_int((int)(FL_TREE_REASON_DESELECTED)));
  SWIG_Python_SetConstant(d, "FL_TREE_REASON_RESELECTED",SWIG_From_int((int)(FL_TREE_REASON_RESELECTED)));
  SWIG_Python_SetConstant(d, "FL_TREE_REASON_OPENED",SWIG_From_int((int)(FL_TREE_REASON_OPENED)));
  SWIG_Python_SetConstant(d, "FL_TREE_REASON_CLOSED",SWIG_From_int((int)(FL_TREE_REASON_CLOSED)));
  SWIG_Python_SetConstant(d, "FL_TREE_REASON_DRAGGED",SWIG_From_int((int)(FL_TREE_REASON_DRAGGED)));
  SWIG_Python_SetConstant(d, "NO_PAGE_FORMATS",SWIG_From_int((int)(30)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A0",SWIG_From_int((int)(Fl_Paged_Device::A0)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A1",SWIG_From_int((int)(Fl_Paged_Device::A1)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A2",SWIG_From_int((int)(Fl_Paged_Device::A2)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A3",SWIG_From_int((int)(Fl_Paged_Device::A3)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A4",SWIG_From_int((int)(Fl_Paged_Device::A4)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A5",SWIG_From_int((int)(Fl_Paged_Device::A5)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A6",SWIG_From_int((int)(Fl_Paged_Device::A6)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A7",SWIG_From_int((int)(Fl_Paged_Device::A7)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A8",SWIG_From_int((int)(Fl_Paged_Device::A8)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A9",SWIG_From_int((int)(Fl_Paged_Device::A9)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B0",SWIG_From_int((int)(Fl_Paged_Device::B0)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B1",SWIG_From_int((int)(Fl_Paged_Device::B1)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B2",SWIG_From_int((int)(Fl_Paged_Device::B2)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B3",SWIG_From_int((int)(Fl_Paged_Device::B3)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B4",SWIG_From_int((int)(Fl_Paged_Device::B4)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B5",SWIG_From_int((int)(Fl_Paged_Device::B5)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B6",SWIG_From_int((int)(Fl_Paged_Device::B6)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B7",SWIG_From_int((int)(Fl_Paged_Device::B7)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B8",SWIG_From_int((int)(Fl_Paged_Device::B8)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B9",SWIG_From_int((int)(Fl_Paged_Device::B9)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B10",SWIG_From_int((int)(Fl_Paged_Device::B10)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_C5E",SWIG_From_int((int)(Fl_Paged_Device::C5E)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_DLE",SWIG_From_int((int)(Fl_Paged_Device::DLE)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_EXECUTIVE",SWIG_From_int((int)(Fl_Paged_Device::EXECUTIVE)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_FOLIO",SWIG_From_int((int)(Fl_Paged_Device::FOLIO)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_LEDGER",SWIG_From_int((int)(Fl_Paged_Device::LEDGER)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_LEGAL",SWIG_From_int((int)(Fl_Paged_Device::LEGAL)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_LETTER",SWIG_From_int((int)(Fl_Paged_Device::LETTER)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_TABLOID",SWIG_From_int((int)(Fl_Paged_Device::TABLOID)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_ENVELOPE",SWIG_From_int((int)(Fl_Paged_Device::ENVELOPE)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_MEDIA",SWIG_From_int((int)(Fl_Paged_Device::MEDIA)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_PORTRAIT",SWIG_From_int((int)(Fl_Paged_Device::PORTRAIT)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_LANDSCAPE",SWIG_From_int((int)(Fl_Paged_Device::LANDSCAPE)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_REVERSED",SWIG_From_int((int)(Fl_Paged_Device::REVERSED)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_ORIENTATION",SWIG_From_int((int)(Fl_Paged_Device::ORIENTATION)));
  SWIG_Python_SetConstant(d, "M_PI",SWIG_From_double((double)(3.14159265358979323846)));
  SWIG_Python_SetConstant(d, "M_PI_2",SWIG_From_double((double)(1.57079632679489661923)));
  SWIG_Python_SetConstant(d, "M_PI_4",SWIG_From_double((double)(0.78539816339744830962)));
  SWIG_Python_SetConstant(d, "M_1_PI",SWIG_From_double((double)(0.31830988618379067154)));
  SWIG_Python_SetConstant(d, "M_2_PI",SWIG_From_double((double)(0.63661977236758134308)));
  SWIG_Python_SetConstant(d, "M_SQRT2",SWIG_From_double((double)(1.41421356237309504880)));
  SWIG_Python_SetConstant(d, "M_SQRT1_2",SWIG_From_double((double)(0.70710678118654752440)));
#if PY_VERSION_HEX >= 0x03000000
  return m;
#else
  return;
#endif
}

